文章目录

LangChain AI 模型的输出

1. LangChain 输出解析器：从模型输出中提取列表

当我们调用大模型时，它返回的是自然语言文本。但在实际应用中，我们往往需要结构化的数据，比如列表、JSON、数字等。手动从文本中提取这些数据既繁琐又容易出错。

LangChain 提供了输出解析器（Output Parser），可以自动将模型的文本输出解析为 Python 对象。下面将以 CommaSeparatedListOutputParser 为例，详细讲解如何从模型输出中提取列表数据。

1.1 完整代码示例和解析

from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts import ChatPromptTemplate

# 1. 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "{parser_instructions}"),
    ("human", "列出5个{subject}色系的十六进制颜色码。")
])

# 2. 创建输出解析器
output_parser = CommaSeparatedListOutputParser()

# 3. 获取格式说明
parser_instructions = output_parser.get_format_instructions()
print(parser_instructions)
# 输出：Your response should be a list of comma separated values, e.g: `foo`, `bar`, `baz` or `foo,bar,baz`

# 4. 格式化提示词（注入变量）
final_prompt = prompt.invoke({
    "subject": "莫兰迪", 
    "parser_instructions": parser_instructions
})

# 5. 创建模型并调用
model = ChatOpenAI(
    model="gpt-3.5-turbo",
    openai_api_key="你的API密钥",
    openai_api_base="https://aigc789.top/v1"
)

response = model.invoke(final_prompt)
print(response.content)
# 输出：#A89F91, #B2ACA6, #92BC84, #7F7B74, #C1B7A4

# 6. 使用解析器提取列表
parsed_list = output_parser.invoke(response)
print(parsed_list)
# 输出：['#A89F91', '#B2ACA6', '#92BC84', '#7F7B74', '#C1B7A4']
print(type(parsed_list))
# 输出：<class 'list'>
1.1.1 导入模块
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts import ChatPromptTemplate
模块 作用
ChatOpenAI OpenAI 模型封装
CommaSeparatedListOutputParser 逗号分隔列表输出解析器，将模型输出解析为 Python 列表
ChatPromptTemplate 聊天提示词模板
1.1.2 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "{parser_instructions}"),
    ("human", "列出5个{subject}色系的十六进制颜色码。")
])

结构解析：

  • System 消息：包含占位符 {parser_instructions}，用于注入输出格式说明
  • Human 消息：包含占位符 {subject}，用于指定颜色色系（如"莫兰迪"）

为什么需要 parser_instructions？
- 模型不知道我们期望什么格式的输出

  • 通过注入格式说明，告诉模型"请用逗号分隔的列表形式返回"
1.1.3 创建输出解析器并获取格式说明
output_parser = CommaSeparatedListOutputParser()
parser_instructions = output_parser.get_format_instructions()
print(parser_instructions)

输出：

Your response should be a list of comma separated values, e.g: `foo`, `bar`, `baz` or `foo,bar,baz`
1.1.4 格式化提示词
final_prompt = prompt.invoke({
    "subject": "莫兰迪", 
    "parser_instructions": parser_instructions
})

作用：

  • 将 subject 替换为 “莫兰迪”
  • 将 parser_instructions 替换为格式说明
    最终生成的 System 消息：
Your response should be a list of comma separated values, e.g: `foo`, `bar`, `baz` or `foo,bar,baz`

最终生成的 Human 消息：

列出5个莫兰迪色系的十六进制颜色码。
1.1.5 调用模型
model = ChatOpenAI(
    model="gpt-3.5-turbo",
    openai_api_key="你的API密钥",
    openai_api_base="https://aigc789.top/v1"
)

response = model.invoke(final_prompt)
print(response.content)

输出：

#A89F91, #B2ACA6, #92BC84, #7F7B74, #C1B7A4

模型按照要求，返回了用逗号分隔的 5 个十六进制颜色码。

1.1.6 使用解析器提取列表
parsed_list = output_parser.invoke(response)
print(parsed_list)
# 输出：['#A89F91', '#B2ACA6', '#92BC84', '#7F7B74', '#C1B7A4']
print(type(parsed_list))
# 输出：<class 'list'>

invoke() 方法的作用：

  • 接收模型返回的 AIMessage 对象
  • 解析其中的文本内容
  • 返回 Python 列表对象

解析过程：

  1. 从 response.content 中提取文本：#A89F91, #B2ACA6, #92BC84, #7F7B74, #C1B7A4
  2. 按逗号分割字符串
  3. 去除每个元素前后的空格
  4. 返回 Python 列表

1.2 完整流程图

┌─────────────────────────────────────────────────────────────────┐
│                        1. 创建输出解析器                         │
│  output_parser = CommaSeparatedListOutputParser()               │
│  parser_instructions = output_parser.get_format_instructions()  │
│  → "Your response should be a list of comma separated values..."│
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                        2. 构建提示词模板                         │
│  prompt = ChatPromptTemplate.from_messages([                    │
│      ("system", "{parser_instructions}"),                       │
│      ("human", "列出5个{subject}色系的十六进制颜色码。")         │
│  ])                                                             │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                      3. 注入变量生成最终提示词                    │
│  final_prompt = prompt.invoke({                                 │
│      "subject": "莫兰迪",                                       │
│      "parser_instructions": parser_instructions                 │
│  })                                                             │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                        4. 调用模型                               │
│  response = model.invoke(final_prompt)                          │
│  response.content = "#A89F91, #B2ACA6, #92BC84, #7F7B74, #C1B7A4"│
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                      5. 解析输出为列表                           │
│  parsed_list = output_parser.invoke(response)                   │
│  → ['#A89F91', '#B2ACA6', '#92BC84', '#7F7B74', '#C1B7A4']      │
└─────────────────────────────────────────────────────────────────┘

1.3 技术要点总结

技术点 说明
输出解析器 将模型的文本输出解析为结构化 Python 对象
get_format_instructions() 获取格式说明，注入到提示词中引导模型输出
invoke() 方法 接收模型返回的 AIMessage，返回解析后的 Python 对象
CommaSeparatedListOutputParser 专门解析逗号分隔的列表，返回 Python list
提示词模板组合 将格式说明作为变量注入 System 消息

1.4 常用输出解析器

解析器 用途 输出类型
CommaSeparatedListOutputParser 解析逗号分隔列表 List[str]
JsonOutputParser 解析 JSON 字符串 Dict
PydanticOutputParser 解析为 Pydantic 模型 Pydantic Model
StrOutputParser 直接返回字符串 str
DatetimeOutputParser 解析日期时间 datetime

1.5 实际应用场景

场景 说明
数据提取 从文本中提取关键词、颜色码、ID 列表
批量生成 生成多个选项、建议、标签
知识问答 返回相关实体的列表
代码生成 生成函数名、变量名列表
分类结果 返回分类标签列表

2. LangChain 输出解析器：从模型输出中提取 JSON

在实际的 AI 应用开发中，我们经常需要从模型的自然语言输出中提取结构化数据。比如从一篇书籍介绍中提取书名、作者、体裁等信息。手动解析文本既繁琐又容易出错。

LangChain 提供了 PydanticOutputParser，可以让我们用 Pydantic 模型定义期望的输出结构，然后自动将模型的输出解析为 Python 对象。下面将详细解析一个从书籍概述中提取信息的完整示例。

2.1 完整代码示例和解析

from typing import List
from pydantic import BaseModel, Field

from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI

# 1. 定义 Pydantic 模型（期望的输出结构）
class BookInfo(BaseModel):
    book_name: str = Field(
        description="书籍的名字", 
        json_schema_extra={"example": "百年孤独"}
    )
    author_name: str = Field(
        description="书籍的作者", 
        json_schema_extra={"example": "加西亚·马尔克斯"}
    )
    genres: List[str] = Field(
        description="书籍的体裁", 
        json_schema_extra={"example": ["小说", "文学"]}
    )

# 2. 创建输出解析器
output_parser = PydanticOutputParser(pydantic_object=BookInfo)

# 3. 获取格式说明（告诉模型应该如何输出）
print(output_parser.get_format_instructions())

# 4. 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "{parser_instructions} 你输出的结果请使用中文。"),
    ("human", "请你帮我从书籍概述中，提取书名、作者，以及书籍的体裁。书籍概述会被三个#符号包围。\n###{book_introduction}###")
])

# 5. 准备书籍概述文本
book_introduction = """《明朝那些事儿》，作者是当年明月。2006年3月在天涯社区首次发表，2009年3月21日连载完毕，边写作边集结成书出版发行，一共7本。
《明朝那些事儿》主要讲述的是从1344年到1644年这三百年间关于明朝的一些故事。以史料为基础，以年代和具体人物为主线，并加入了小说的笔法，语言幽默风趣。对明朝十六帝和其他王公权贵和小人物的命运进行全景展示，尤其对官场政治、战争、帝王心术着墨最多，并加入对当时政治经济制度、人伦道德的演义。
它以一种网络语言向读者娓娓道出三百多年关于明朝的历史故事、人物。其中原本在历史中陌生、模糊的历史人物在书中一个个变得鲜活起来。《明朝那些事儿》为读者解读历史中的另一面，让历史变成一部活生生的生活故事。
"""

# 6. 格式化提示词（注入书籍概述和格式说明）
final_prompt = prompt.invoke({
    "book_introduction": book_introduction, 
    "parser_instructions": output_parser.get_format_instructions()
})

# 7. 创建模型并调用
model = ChatOpenAI(
    model="gpt-3.5-turbo", 
    openai_api_key="你的API密钥",
    openai_api_base="https://aigc789.top/v1"
)

response = model.invoke(final_prompt)
print("模型输出：")
print(response.content)

# 8. 使用解析器提取结构化数据
result = output_parser.invoke(response)

# 9. 访问解析后的属性
print(f"\n书名：{result.book_name}")
print(f"作者：{result.author_name}")
print(f"体裁：{result.genres}")
2.1.1 导入模块
from typing import List
from pydantic import BaseModel, Field

from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
模块 作用
BaseModel, Field 定义 Pydantic 数据模型
PydanticOutputParser 将模型输出解析为 Pydantic 对象
ChatPromptTemplate 创建聊天提示词模板
ChatOpenAI OpenAI 模型封装
2.1.2 定义 Pydantic 模型（核心）
class BookInfo(BaseModel):
    book_name: str = Field(
        description="书籍的名字", 
        json_schema_extra={"example": "百年孤独"}
    )
    author_name: str = Field(
        description="书籍的作者", 
        json_schema_extra={"example": "加西亚·马尔克斯"}
    )
    genres: List[str] = Field(
        description="书籍的体裁", 
        json_schema_extra={"example": ["小说", "文学"]}
    )

这个模型定义了期望的输出结构：

  • book_name：字符串类型，书籍名称
  • author_name：字符串类型，作者姓名
  • genres：字符串列表，书籍体裁

Field 的作用：

  • description：字段描述，帮助模型理解要提取什么
  • json_schema_extra：提供示例值，引导模型输出格式
2.1.3 创建输出解析器
output_parser = PydanticOutputParser(pydantic_object=BookInfo)
  • 将 Pydantic 模型传给解析器
  • 解析器知道期望的输出结构
2.1.4 获取格式说明
print(output_parser.get_format_instructions())

输出示例：

The output should be formatted as a JSON instance that conforms to the JSON schema below.

As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

Here is the output schema:
{"properties": {"book_name": {"description": "书籍的名字", "example": "百年孤独", "title": "Book Name", "type": "string"}, "author_name": {"description": "书籍的作者", "example": "加西亚·马尔克斯", "title": "Author Name", "type": "string"}, "genres": {"description": "书籍的体裁", "example": ["小说", "文学"], "items": {"type": "string"}, "title": "Genres", "type": "array"}}, "required": ["book_name", "author_name", "genres"]}

作用：告诉模型应该输出什么样的 JSON 格式

2.1.5 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "{parser_instructions} 你输出的结果请使用中文。"),
    ("human", "请你帮我从书籍概述中，提取书名、作者，以及书籍的体裁。书籍概述会被三个#符号包围。\n###{book_introduction}###")
])
  • System 消息：注入格式说明，并强调输出使用中文
  • Human 消息：包含书籍概述的占位符
2.1.6 格式化提示词
final_prompt = prompt.invoke({
    "book_introduction": book_introduction, 
    "parser_instructions": output_parser.get_format_instructions()
})

将书籍概述和格式说明注入模板，生成最终的提示词。

2.1.7 调用模型
response = model.invoke(final_prompt)
print(response.content)

模型输出示例：

{
  "book_name": "明朝那些事儿",
  "author_name": "当年明月",
  "genres": ["历史", "小说", "通俗读物"]
}
2.1.8 解析输出
result = output_parser.invoke(response)
  • invoke() 方法接收模型返回的 AIMessage
  • 自动提取其中的 JSON 字符串
  • 验证 JSON 是否符合 BookInfo 模型
  • 返回 BookInfo 对象
2.1.9 访问解析后的属性
print(f"书名：{result.book_name}")   # 书名：明朝那些事儿
print(f"作者：{result.author_name}") # 作者：当年明月
print(f"体裁：{result.genres}")      # 体裁：['历史', '小说', '通俗读物']

现在可以像操作普通 Python 对象一样访问数据！

2.2 完整流程图

┌─────────────────────────────────────────────────────────────────┐
│                   1. 定义 Pydantic 模型                          │
│  class BookInfo(BaseModel):                                     │
│      book_name: str                                             │
│      author_name: str                                           │
│      genres: List[str]                                          │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                   2. 创建输出解析器                              │
│  parser = PydanticOutputParser(pydantic_object=BookInfo)        │
│  format_instructions = parser.get_format_instructions()         │
│  → 告诉模型 JSON 格式要求                                        │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                   3. 构建提示词                                  │
│  system: {format_instructions} 你输出的结果请使用中文。          │
│  human: 从书籍概述中提取...###{book_introduction}###            │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                   4. 调用模型                                    │
│  response = model.invoke(final_prompt)                          │
│  → {"book_name": "明朝那些事儿", "author_name": "当年明月", ...}  │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                   5. 解析输出                                    │
│  result = parser.invoke(response)                               │
│  → BookInfo(book_name="明朝那些事儿", author_name="当年明月", ...)│
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│                   6. 使用数据                                    │
│  result.book_name  → "明朝那些事儿"                              │
│  result.author_name → "当年明月"                                 │
│  result.genres      → ["历史", "小说", "通俗读物"]                │
└─────────────────────────────────────────────────────────────────┘

2.3 技术要点总结

| 技术点 | 说明 |
|--------|------|
| **Pydantic 模型** | 定义期望的输出结构，包括字段类型和描述 |
| **PydanticOutputParser** | 将模型输出解析为 Pydantic 对象 |
| **get_format_instructions()** | 获取 JSON 格式说明，注入到提示词中 |
| **invoke() 方法** | 接收 AIMessage，返回解析后的 Pydantic 对象 |
| **类型安全** | 解析后的对象有完整的类型提示和自动补全 |

2.4 常见输出解析器对比

解析器 用途 输出类型
PydanticOutputParser 解析为 Pydantic 模型 Pydantic Model
JsonOutputParser 解析 JSON 字符串 Dict
CommaSeparatedListOutputParser 解析逗号分隔列表 List[str]
StrOutputParser 直接返回字符串 str

2.5 实际应用场景

场景 说明
信息提取 从非结构化文本中提取结构化信息
数据标注 自动为文本添加标签、分类
表单填充 从对话中提取字段填充表单
实体识别 识别人名、地名、组织名等实体
意图分类 将用户输入分类到预定义类别

3. LangChain 表达式语言（LCEL）：用 | 管道符串联提示模板、模型和输出解析器

在前面的示例中，我们都是一步一步地手动调用：创建提示词 → 格式化 → 调用模型 → 解析输出。这种方式虽然清晰，但代码略显冗长。

LangChain 提供了表达式语言（LCEL，LangChain Expression Language），可以使用 | 管道符将各个组件串联起来，形成一个可执行的链（Chain）。这不仅让代码更简洁，还让整个流程一目了然。

下面我将详细解析一个使用 | 串联提示模板、模型和输出解析器的完整示例。

3.1 完整代码示例和解析

from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts import ChatPromptTemplate

# 1. 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "{parser_instructions}"),
    ("human", "列出5个{subject}色系的十六进制颜色码。")
])

# 2. 创建输出解析器
output_parser = CommaSeparatedListOutputParser()

# 3. 获取格式说明
parser_instructions = output_parser.get_format_instructions()

# 4. 创建模型
model = ChatOpenAI(
    model="gpt-3.5-turbo",
    openai_api_key="你的API密钥",
    openai_api_base="https://aigc789.top/v1"
)

# 5. 方式一：分步调用（不推荐）
result = output_parser.invoke(
    model.invoke(
        prompt.invoke({
            "subject": "莫兰迪", 
            "parser_instructions": parser_instructions
        })
    )
)
print("分步调用结果：", result)

# 6. 方式二：使用管道符串联（推荐）
chain = prompt | model | output_parser
result = chain.invoke({
    "subject": "莫兰迪", 
    "parser_instructions": parser_instructions
})
print("管道串联结果：", result)
3.1.1 导入模块
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts import ChatPromptTemplate
模块 作用
ChatOpenAI OpenAI 模型封装
CommaSeparatedListOutputParser 逗号分隔列表输出解析器
ChatPromptTemplate 聊天提示词模板
3.1.2 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "{parser_instructions}"),
    ("human", "列出5个{subject}色系的十六进制颜色码。")
])
  • System 消息：包含占位符 {parser_instructions}，用于注入输出格式说明
  • Human 消息：包含占位符 {subject}，用于指定颜色色系
3.1.3 创建输出解析器并获取格式说明
output_parser = CommaSeparatedListOutputParser()
parser_instructions = output_parser.get_format_instructions()
  • CommaSeparatedListOutputParser：专门解析逗号分隔的列表
  • get_format_instructions()：返回格式说明，告诉模型应该输出什么格式
3.1.4 创建模型
model = ChatOpenAI(
    model="gpt-3.5-turbo",
    openai_api_key="你的API密钥",
    openai_api_base="https://aigc789.top/v1"
)
3.1.4.1 方式一：分步调用（不推荐）
result = output_parser.invoke(
    model.invoke(
        prompt.invoke({
            "subject": "莫兰迪", 
            "parser_instructions": parser_instructions
        })
    )
)

执行顺序（从内到外）：

  1. prompt.invoke(...)：格式化提示词，生成消息列表
  2. model.invoke(...)：调用模型，获取响应
  3. output_parser.invoke(...)：解析响应，返回列表

问题：

  • 代码嵌套深，可读性差
  • 添加新组件时需要修改嵌套结构
  • 调试困难
3.1.4.2 方式二：使用管道符串联（推荐）
chain = prompt | model | output_parser
result = chain.invoke({
    "subject": "莫兰迪", 
    "parser_instructions": parser_instructions
})

这就是 LCEL 的核心语法

  • | 管道符将三个组件串联成一个链（Chain）：
  • 数据从左到右流动
  • 每个组件的输出自动成为下一个组件的输入

3.2 管道符的工作原理

┌─────────────────────────────────────────────────────────────────┐
│                     chain = prompt | model | output_parser      │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│  输入字典                                                        │
│  {"subject": "莫兰迪", "parser_instructions": "..."}            │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 1: prompt                                                  │
│  输入：字典                                                      │
│  输出：消息列表 (List[BaseMessage])                               │
│  → [SystemMessage(content="..."), HumanMessage(content="...")]   │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 2: model                                                   │
│  输入：消息列表                                                  │
│  输出：AIMessage                                                 │
│  → AIMessage(content="#A89F91, #B2ACA6, #92BC84, #7F7B74, ...")  │
└─────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────┐
│  Step 3: output_parser                                           │
│  输入：AIMessage                                                 │
│  输出：List[str]                                                 │
│  → ['#A89F91', '#B2ACA6', '#92BC84', '#7F7B74', '#C1B7A4']       │
└─────────────────────────────────────────────────────────────────┘

注意：必须确保前一个组件的输出类型与后一个组件的输入类型匹配

  • prompt 输出 → model 输入（消息列表）
  • model 输出 → parser 输入（AIMessage）

3.3 两种方式对比

对比项 分步调用（嵌套） 管道串联（LCEL）
代码可读性 嵌套深，难读 线性结构，清晰
可维护性 添加组件需改嵌套 直接添加管道符
调试难度 难以定位问题 可拆开测试
扩展性 差 好
代码量 多 少

3.4 LCEL 的核心优势

3.4.1 代码简洁
# 传统方式
prompt_value = prompt.invoke(input_data)
response = model.invoke(prompt_value)
result = output_parser.invoke(response)

# LCEL 方式
chain = prompt | model | output_parser
result = chain.invoke(input_data)
3.4.2 易于扩展
# 添加更多组件
chain = prompt | model | output_parser | another_processor
3.4.3 支持并行执行
# 可以同时运行多个链
from langchain_core.runnables import RunnableParallel

chain = RunnableParallel({
    "result1": chain1,
    "result2": chain2,
})
3.4.4 支持流式输出
# 可以逐 token 输出
for chunk in chain.stream(input_data):
    print(chunk, end="", flush=True)

3.5 技术要点总结

对比项 分步调用（嵌套） 管道串联（LCEL）
代码可读性 嵌套深，难读 线性结构，清晰
可维护性 添加组件需改嵌套 直接添加管道符
调试难度 难以定位问题 可拆开测试
扩展性 差 好
代码量 多 少

3.6 实际应用场景

场景 说明
问答系统 `检索
翻译工具 `提示词
数据分析 `提示词
内容生成 `提示词
# AI
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

Agent 能适配国产化系统吗？深度拆解2026国产信创环境下的智能体架构与落地路径

avatar AtomGit开源社区
cover

开源软件的商业可持续性：爱、热血与面包的难题

avatar AtomGit开源社区
cover

重庆合川发布陶行知AI数字人，世优科技提供数字人全栈技术支持

avatar AtomGit开源社区