diff --git a/pipeline/core/builder.py b/pipeline/core/builder.py index 1671807f2..ba4884aee 100644 --- a/pipeline/core/builder.py +++ b/pipeline/core/builder.py @@ -95,6 +95,10 @@ def build_all(self) -> None: logger.info("Building LangSmith content...") self._build_unversioned_content("langsmith", "langsmith") + # Build localized content directories (ko/, cn/, es/, zh-Hant/) + logger.info("Building localized content...") + self._build_localized_content() + # Copy shared files (docs.json, images, etc.) logger.info("Copying shared files...") self._copy_shared_files() @@ -636,6 +640,169 @@ def _build_unversioned_content(self, source_dir: str, output_dir: str) -> None: skipped_count, ) + def _build_localized_content(self) -> None: + """Build localized content directories (ko/, cn/, es/, zh-Hant/). + + This method scans for localized content directories in src/ and copies them + to the build directory, maintaining the directory structure. + + If a localized directory contains an oss/ subdirectory, that content will be + versioned into python/ and javascript/ variants. + """ + # Common language codes for localized content + localized_dirs = ["ko", "cn", "es", "zh-Hant", "ja", "de", "fr", "pt", "ru"] + + for lang_code in localized_dirs: + src_path = self.src_dir / lang_code + if src_path.exists() and src_path.is_dir(): + logger.info("Building %s/ content...", lang_code) + + # Check if this localized directory has an oss/ subdirectory + oss_path = src_path / "oss" + if oss_path.exists() and oss_path.is_dir(): + # Build versioned OSS content + logger.info("Building %s/oss/ Python version...", lang_code) + self._build_localized_oss_version(lang_code, "python") + + logger.info("Building %s/oss/ JavaScript version...", lang_code) + self._build_localized_oss_version(lang_code, "js") + + # Build non-oss content as unversioned + self._build_localized_non_oss_content(lang_code) + + def _build_localized_oss_version( + self, lang_code: str, target_language: str + ) -> None: + """Build localized OSS content for a specific language version. + + Args: + lang_code: Language code for the locale (e.g., "ko", "cn"). + target_language: Target language for conditional blocks ("python" or "js"). + """ + oss_dir = self.src_dir / lang_code / "oss" + if not oss_dir.exists(): + return + + # Get all files in the localized oss directory + all_files = [ + file_path + for file_path in oss_dir.rglob("*") + if file_path.is_file() and not self.is_shared_file(file_path) + ] + + if not all_files: + logger.info("No files found in %s/oss/ directory", lang_code) + return + + # Map target_language to directory name + # target_language is "python" or "js", but directory is "python" or "javascript" + lang_dir = self.language_url_names.get(target_language, target_language) + + # Process files with progress bar + copied_count: int = 0 + skipped_count: int = 0 + + with tqdm( + total=len(all_files), + desc=f"Building {lang_code}/oss/{lang_dir} files", + unit="file", + ncols=80, + bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]", + ) as pbar: + for file_path in all_files: + # Calculate relative path from oss/ directory + relative_path = file_path.relative_to(oss_dir) + + # Build to {lang_code}/oss/{lang_dir}/ structure + output_path = ( + self.build_dir / lang_code / "oss" / lang_dir / relative_path + ) + + result = self._build_single_file( + file_path, + output_path, + target_language, + pbar, + f"{lang_code}/oss/{lang_dir}/{relative_path}", + ) + if result: + copied_count += 1 + else: + skipped_count += 1 + pbar.update(1) + + logger.info( + "✅ %s/oss/%s complete: %d files copied, %d files skipped", + lang_code, + lang_dir, + copied_count, + skipped_count, + ) + + def _build_localized_non_oss_content(self, lang_code: str) -> None: + """Build non-OSS content for a localized directory. + + Args: + lang_code: Language code for the locale (e.g., "ko", "cn"). + """ + src_path = self.src_dir / lang_code + if not src_path.exists(): + return + + # Get all files EXCEPT those in the oss/ subdirectory + all_files = [] + for file_path in src_path.rglob("*"): + if file_path.is_file() and not self.is_shared_file(file_path): + # Skip files that are in the oss/ subdirectory + try: + relative_to_lang = file_path.relative_to(src_path) + if relative_to_lang.parts and relative_to_lang.parts[0] == "oss": + continue + all_files.append(file_path) + except ValueError: + continue + + if not all_files: + logger.info("No non-OSS files found in %s/ directory", lang_code) + return + + # Process files with progress bar + copied_count: int = 0 + skipped_count: int = 0 + + with tqdm( + total=len(all_files), + desc=f"Building {lang_code} non-OSS files", + unit="file", + ncols=80, + bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]", + ) as pbar: + for file_path in all_files: + # Calculate relative path from lang directory + relative_path = file_path.relative_to(src_path) + # Build directly to {lang_code}/ + output_path = self.build_dir / lang_code / relative_path + + result = self._build_single_file( + file_path, + output_path, + "python", # Use python as default for non-OSS localized content + pbar, + f"{lang_code}/{relative_path}", + ) + if result: + copied_count += 1 + else: + skipped_count += 1 + pbar.update(1) + + logger.info( + "✅ %s non-OSS complete: %d files copied, %d files skipped", + lang_code, + copied_count, + skipped_count, + ) + def _build_single_file( self, file_path: Path, diff --git a/src/docs.json b/src/docs.json index 5754c04b4..50837930d 100644 --- a/src/docs.json +++ b/src/docs.json @@ -1420,6 +1420,49 @@ ] } ] + }, + { + "language": "ko", + "products": [ + { + "product": "Home", + "icon": "house", + "pages": [ + "ko/index" + ] + }, + { + "product": "LangChain + LangGraph", + "icon": "link", + "description": "Open source frameworks", + "dropdowns": [ + { + "dropdown": "Python", + "icon": "python", + "tabs": [ + { + "tab": "LangChain", + "pages": [ + "ko/oss/python/langchain/overview" + ] + } + ] + }, + { + "dropdown": "JavaScript", + "icon": "square-js", + "tabs": [ + { + "tab": "LangChain", + "pages": [ + "ko/oss/javascript/langchain/overview" + ] + } + ] + } + ] + } + ] } ] }, diff --git a/src/ko/index.mdx b/src/ko/index.mdx new file mode 100644 index 000000000..778089058 --- /dev/null +++ b/src/ko/index.mdx @@ -0,0 +1,140 @@ +--- +title: +sidebarTitle: Home +mode: "custom" +--- + +This is a placeholder page. It should follow the same format as src/index.mdx. + + +
+
+

Documentation

+ + LangChain is the platform for agent engineering. AI teams at Replit, Clay, Rippling, Cloudflare, Workday, and more trust LangChain's products to engineer reliable agents. + + Our **open source frameworks** help you build agents: + + - [**LangChain**](/oss/python/langchain/overview) helps you quickly get started building agents, with any model provider of your choice. + - [**LangGraph**](/oss/python/langgraph/overview) allows you to control every step of your custom agent with low-level orchestration, memory, and human-in-the-loop support. You can manage long-running tasks with durable execution. + + [**LangSmith**](/langsmith/home) is a platform that helps AI teams use live production data for continuous testing and improvement. LangSmith provides: + + - **Observability** to see exactly how your agent thinks and acts with detailed tracing and aggregate trend metrics. + - **Evaluation** to test and score agent behavior on production data and offline datasets for continuous improvement. + - **Deployment** to ship your agent in one click, using scalable infrastructure built for long-running tasks. + + + LangGraph Platform is now [LangSmith Deployment](/langsmith/deployments). For more information, check out the [Changelog](https://changelog.langchain.com/announcements/product-naming-changes-langsmith-deployment-and-langsmith-studio). + + +

Get started

+ + + + + + + + +

Open source agent frameworks

+ + + + + + Quickly get started building agents, with any model provider of your choice. + + + Control every step of your custom agent with low-level orchestration, memory, and human-in-the-loop support. + + + Build agents that can tackle complex, multi-step tasks. + + + + + + + Quickly get started building agents, with any model provider of your choice. + + + Control every step of your custom agent with low-level orchestration, memory, and human-in-the-loop support. + + + + + +

LangSmith

+ + + + See exactly how your agent thinks and acts with detailed tracing and aggregate trend metrics. + + + Test and score agent behavior on production data or offline datasets to continuously improve performance. + + + Iterate on prompts with version control, prompt optimization, and collaboration features. + + + Ship your agent in one click, using scalable infrastructure built for long-running tasks. + + + + + LangSmith meets the highest standards of data security and privacy with HIPAA, SOC 2 Type 2, and GDPR compliance. For more information, see the [Trust Center](https://trust.langchain.com/). + +
+
+ +{/* Hack to hide the callout cards*/} +
+
+
+
diff --git a/src/ko/oss/langchain/overview.mdx b/src/ko/oss/langchain/overview.mdx new file mode 100644 index 000000000..8e79a564a --- /dev/null +++ b/src/ko/oss/langchain/overview.mdx @@ -0,0 +1,142 @@ +--- +title: LangChain 개요 +sidebarTitle: 개요 +--- + +This is a placeholder page. It should follow the same format as src/oss/langchain/overview.mdx. + + +:::python + + **LangChain v1.0 is now available!** + + For a complete list of changes and instructions on how to upgrade your code, see the [release notes](/oss/releases/langchain-v1) and [migration guide](/oss/migrate/langchain-v1). + + If you encounter any issues or have feedback, please [open an issue](https://github.com/langchain-ai/docs/issues/new?template=01-langchain.yml) so we can improve. To view v0.x documentation, [go to the archived content](https://github.com/langchain-ai/langchain/tree/v0.3/docs/docs). + +::: + +:::js + + **LangChain v1.0 is now available!** + + For a complete list of changes and instructions on how to upgrade your code, see the [release notes](/oss/releases/langchain-v1) and [migration guide](/oss/migrate/langchain-v1). + + If you encounter any issues or have feedback, please [open an issue](https://github.com/langchain-ai/docs/issues/new?template=01-langchain.yml) so we can improve. To view v0.x documentation, [go to the archived content](https://github.com/langchain-ai/langchainjs/tree/v0.3/docs/core_docs/docs). + +::: + +LangChain is the easiest way to start building agents and applications powered by LLMs. With under 10 lines of code, you can connect to OpenAI, Anthropic, Google, and [more](/oss/integrations/providers/overview). LangChain provides a pre-built agent architecture and model integrations to help you get started quickly and seamlessly incorporate LLMs into your agents and applications. + +We recommend you use LangChain if you want to quickly build agents and autonomous applications. Use [LangGraph](/oss/langgraph/overview), our low-level agent orchestration framework and runtime, when you have more advanced needs that require a combination of deterministic and agentic workflows, heavy customization, and carefully controlled latency. + +LangChain [agents](/oss/langchain/agents) are built on top of LangGraph in order to provide durable execution, streaming, human-in-the-loop, persistence, and more. You do not need to know LangGraph for basic LangChain agent usage. + +## Install + +:::python + +```bash pip +pip install -U langchain +``` + +```bash uv +uv add langchain +``` + +::: +:::js + +```bash npm +npm install langchain @langchain/core +``` + +```bash pnpm +pnpm add langchain @langchain/core +``` + +```bash yarn +yarn add langchain @langchain/core +``` + +```bash bun +bun add langchain @langchain/core +``` + +::: + +## Create an agent + +:::python +```python +# pip install -qU "langchain[anthropic]" to call the model + +from langchain.agents import create_agent + +def get_weather(city: str) -> str: + """Get weather for a given city.""" + return f"It's always sunny in {city}!" + +agent = create_agent( + model="claude-sonnet-4-5-20250929", + tools=[get_weather], + system_prompt="You are a helpful assistant", +) + +# Run the agent +agent.invoke( + {"messages": [{"role": "user", "content": "what is the weather in sf"}]} +) +``` +::: + +:::js +```ts +import * as z from "zod"; +// npm install @langchain/anthropic to call the model +import { createAgent, tool } from "langchain"; + +const getWeather = tool( + ({ city }) => `It's always sunny in ${city}!`, + { + name: "get_weather", + description: "Get the weather for a given city", + schema: z.object({ + city: z.string(), + }), + }, +); + +const agent = createAgent({ + model: "claude-sonnet-4-5-20250929", + tools: [getWeather], +}); + +console.log( + await agent.invoke({ + messages: [{ role: "user", content: "What's the weather in Tokyo?" }], + }) +); +``` +::: + + +## Core benefits + + + + Different providers have unique APIs for interacting with models, including the format of responses. LangChain standardizes how you interact with models so that you can seamlessly swap providers and avoid lock-in. + + + + LangChain's agent abstraction is designed to be easy to get started with, letting you build a simple agent in under 10 lines of code. But it also provides enough flexibility to allow you to do all the context engineering your heart desires. + + + + LangChain's agents are built on top of LangGraph. This allows us to take advantage of LangGraph's durable execution, human-in-the-loop support, persistence, and more. + + + + Gain deep visibility into complex agent behavior with visualization tools that trace execution paths, capture state transitions, and provide detailed runtime metrics. + +