输出解析与结构化#

1
这部电影的评分是 8.5 分，导演是克里斯托弗·诺兰，主演包括莱昂纳多·迪卡普里奥……

1
chain = prompt | model | output_parser

1
# pip install langchain langchain-openai
2

3
from langchain_openai import ChatOpenAI
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import StrOutputParser
6

7
# 创建模型
8
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
9

10
# 创建 prompt
11
prompt = ChatPromptTemplate.from_messages([
12
    ("system", "你是一位专业的翻译助手。"),
13
    ("human", "请将以下中文翻译为英文：{text}")
14
])
15

16
# 构建 LCEL 管道 —— StrOutputParser 提取纯文本
17
chain = prompt | model | StrOutputParser()
18

19
# 调用
20
result = chain.invoke({"text": "大语言模型正在改变软件开发的方式。"})
21
print(result)
22
# 输出: "Large language models are changing the way software is developed."
23
print(type(result))
24
# 输出: <class 'str'>

1
# pip install langchain langchain-openai
2

3
from langchain_openai import ChatOpenAI
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import CommaSeparatedListOutputParser
6

7
# 创建解析器
8
parser = CommaSeparatedListOutputParser()
9

10
# 获取格式指令 —— 这将被注入到 prompt 中
11
format_instructions = parser.get_format_instructions()
12
print(format_instructions)
13
# 输出: "Your response should be a list of comma separated values, eg: `foo, bar, baz`"
14

15
# 创建 prompt，注入格式指令
16
prompt = ChatPromptTemplate.from_template(
17
    "列出 {count} 种常见的 {subject}。\n{format_instructions}"
18
)
19

20
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
21

22
# 构建管道
23
chain = prompt | model | parser
24

25
# 调用
26
result = chain.invoke({
27
    "count": "5",
28
    "subject": "排序算法",
29
    "format_instructions": format_instructions
30
})
31

32
print(result)
33
# 输出: ['冒泡排序', '快速排序', '归并排序', '堆排序', '插入排序']
34
print(type(result))
35
# 输出: <class 'list'>

1
# pip install langchain langchain-openai pydantic
2

3
from langchain_openai import ChatOpenAI
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import JsonOutputParser
6
from pydantic import BaseModel, Field
7

8
# 定义期望的 JSON 结构（通过 Pydantic 模型）
9
class MovieReview(BaseModel):
10
    title: str = Field(description="电影名称")
11
    rating: float = Field(description="评分，1-10 的浮点数")
12
    summary: str = Field(description="一句话影评")
13
    recommend: bool = Field(description="是否推荐")
14

15
# 创建解析器，传入 Pydantic 模型来约束 JSON 结构
16
parser = JsonOutputParser(pydantic_object=MovieReview)
17

18
prompt = ChatPromptTemplate.from_template(
19
    "请对电影《{movie}》进行评价。\n{format_instructions}"
20
)
21

22
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
23

24
chain = prompt | model | parser
25

26
result = chain.invoke({
27
    "movie": "盗梦空间",
28
    "format_instructions": parser.get_format_instructions()
29
})
30

31
print(result)
32
# 输出: {'title': '盗梦空间', 'rating': 9.2, 'summary': '...', 'recommend': True}
33
print(type(result))
34
# 输出: <class 'dict'>

1
# 流式调用示例
2
async for chunk in chain.astream({"movie": "星际穿越", "format_instructions": parser.get_format_instructions()}):
3
    print(chunk)
4
    # 逐步输出:
5
    # {}
6
    # {'title': ''}
7
    # {'title': '星际'}
8
    # {'title': '星际穿越'}
9
    # {'title': '星际穿越', 'rating': 9.5}
10
    # ...

1
# Pydantic 基础示例
2
from pydantic import BaseModel, Field
3

4
class Book(BaseModel):
5
    title: str = Field(description="书名")
6
    author: str = Field(description="作者")
7
    pages: int = Field(description="页数", gt=0)
8
    rating: float = Field(description="评分", ge=0, le=10)
9

10
# 合法数据 —— 通过验证
11
book = Book(title="Python 编程", author="Guido", pages=500, rating=9.0)
12

13
# 非法数据 —— 抛出 ValidationError
14
# Book(title="Python 编程", author="Guido", pages=-1, rating=11.0)

1
get_format_instructions() → 生成格式指令 → 注入到 PromptTemplate → 发送给模型

1
The output should be formatted as a JSON instance that conforms to the JSON schema below.
2
Here is the output schema:
3
{"properties": {"title": {"description": "书名", "type": "string"}, ...}, "required": [...]}

1
模型返回文本 → 提取 JSON 部分 → json.loads() → Pydantic 模型验证 → 返回模型实例

1
# pip install langchain langchain-openai pydantic
2

3
from langchain_openai import ChatOpenAI
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain_core.output_parsers import PydanticOutputParser
6
from pydantic import BaseModel, Field
7
from typing import List
8

9
# ===== 第一步：定义 Pydantic 模型 =====
10
class TechArticle(BaseModel):
11
    """科技文章的结构化摘要"""
12
    title: str = Field(description="文章标题")
13
    author: str = Field(description="作者姓名")
14
    summary: str = Field(description="200 字以内的摘要")
15
    key_points: List[str] = Field(description="3-5 个核心要点")
16
    tech_stack: List[str] = Field(description="涉及的技术栈")
17
    difficulty: str = Field(description="难度等级：入门/中级/高级")
18

19
# ===== 第二步：创建 Parser =====
20
parser = PydanticOutputParser(pydantic_object=TechArticle)
21

22
# ===== 第三步：注入 Prompt =====
23
prompt = ChatPromptTemplate.from_template(
24
    """请根据以下文章内容，生成结构化摘要。
25

26
文章内容：
27
{article_text}
28

29
{format_instructions}"""
30
)
31

32
# ===== 第四步：构建管道并调用 =====
33
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
34
chain = prompt | model | parser
35

36
result = chain.invoke({
37
    "article_text": "（这里放入文章内容）",
38
    "format_instructions": parser.get_format_instructions()
39
})
40

41
# ===== 第五步：使用解析结果 =====
42
print(type(result))       # <class 'TechArticle'>
43
print(result.title)        # 直接通过属性访问
44
print(result.key_points)   # 列表类型，可直接遍历
45
print(result.model_dump()) # 转为字典

1
# 不好的做法 —— 模型不知道字段含义
2
class Bad(BaseModel):
3
    d: str
4
    s: float
5

6
# 好的做法 —— 描述清晰，模型准确率更高
7
class Good(BaseModel):
8
    difficulty: str = Field(description="难度等级，取值为 '入门'、'中级' 或 '高级' 之一")
9
    score: float = Field(description="综合评分，范围 0.0 到 10.0")

1
# pip install langchain langchain-openai pydantic
2

3
from pydantic import BaseModel, Field
4
from typing import List, Optional
5
from langchain_core.output_parsers import PydanticOutputParser
6

7
class Address(BaseModel):
8
    """地址信息"""
9
    city: str = Field(description="城市")
10
    district: str = Field(description="区/县")
11
    street: str = Field(description="街道地址")
12

13
class ContactInfo(BaseModel):
14
    """联系方式"""
15
    phone: str = Field(description="电话号码")
16
    email: Optional[str] = Field(default=None, description="电子邮箱，可选")
17

18
class Company(BaseModel):
19
    """公司信息 —— 嵌套结构"""
20
    name: str = Field(description="公司名称")
21
    industry: str = Field(description="所属行业")
22
    employee_count: int = Field(description="员工人数")
23
    address: Address = Field(description="公司地址")
24
    contact: ContactInfo = Field(description="联系方式")
25
    products: List[str] = Field(description="主要产品列表")
26

27
parser = PydanticOutputParser(pydantic_object=Company)
28
print(parser.get_format_instructions())
29
# 输出的 JSON schema 会自动展开嵌套结构

1
# pip install langchain langchain-openai pydantic
2

3
from langchain_openai import ChatOpenAI
4
from langchain_core.output_parsers import PydanticOutputParser
5
from langchain.output_parsers import OutputFixingParser
6
from pydantic import BaseModel, Field
7

8
class Person(BaseModel):
9
    name: str = Field(description="姓名")
10
    age: int = Field(description="年龄")
11

12
base_parser = PydanticOutputParser(pydantic_object=Person)
13
fix_model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
14

15
# 用 OutputFixingParser 包装原始解析器
16
fixing_parser = OutputFixingParser.from_llm(
17
    parser=base_parser,
18
    llm=fix_model
19
)
20

21
# 模拟一个格式错误的输出
22
bad_output = '{"name": "张三", "age": "二十五"}'  # age 应为 int
23

24
# 普通 parser 会报错，fixing_parser 会自动修复
25
result = fixing_parser.parse(bad_output)
26
print(result)
27
# 输出: name='张三' age=25

1
# pip install langchain langchain-openai
2

3
from langchain_openai import ChatOpenAI
4
from langchain_core.prompts import ChatPromptTemplate
5
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
6

7
# 定义输出结构
8
response_schemas = [
9
    ResponseSchema(name="answer", description="回答用户问题的内容"),
10
    ResponseSchema(name="confidence", description="对答案的置信度，取值 high/medium/low"),
11
    ResponseSchema(name="source", description="信息来源，如果不确定则填写 '未知'"),
12
]
13

14
# 创建解析器
15
parser = StructuredOutputParser.from_response_schemas(response_schemas)
16

17
# 查看生成的格式指令
18
format_instructions = parser.get_format_instructions()
19

20
prompt = ChatPromptTemplate.from_template(
21
    "请回答以下问题：\n{question}\n\n{format_instructions}"
22
)
23

24
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
25
chain = prompt | model | parser
26

27
result = chain.invoke({
28
    "question": "Python 的 GIL 是什么？",
29
    "format_instructions": format_instructions
30
})
31

32
print(result)
33
# 输出: {'answer': '...', 'confidence': 'high', 'source': '...'}
34
print(type(result))
35
# 输出: <class 'dict'>

1
# pip install langchain langchain-openai
2

3
from langchain_core.output_parsers import BaseOutputParser
4
from langchain_openai import ChatOpenAI
5
from langchain_core.prompts import ChatPromptTemplate
6
from typing import Dict
7
import re
8

9
class XMLOutputParser(BaseOutputParser[Dict[str, str]]):
10
    """将模型输出的 XML 格式解析为字典"""
11

12
    fields: list[str] = []  # 期望的字段列表
13

14
    @property
15
    def _type(self) -> str:
16
        return "xml"
17

18
    def get_format_instructions(self) -> str:
19
        field_tags = "\n".join(
20
            [f"  <{f}>值</{f}>" for f in self.fields]
21
        )
22
        return f"请严格按照以下 XML 格式输出：\n<output>\n{field_tags}\n</output>"
23

24
    def parse(self, text: str) -> Dict[str, str]:
25
        result = {}
26
        for field in self.fields:
27
            pattern = f"<{field}>(.*?)</{field}>"
28
            match = re.search(pattern, text, re.DOTALL)
29
            if match:
30
                result[field] = match.group(1).strip()
31
            else:
32
                result[field] = ""
33
        return result
34

35
# 使用自定义解析器
36
parser = XMLOutputParser(fields=["sentiment", "reason", "score"])
37

38
prompt = ChatPromptTemplate.from_template(
39
    "分析以下文本的情感：\n{text}\n\n{format_instructions}"
40
)
41

42
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
43
chain = prompt | model | parser
44

45
result = chain.invoke({
46
    "text": "这家餐厅的菜品非常美味，服务也很周到！",
47
    "format_instructions": parser.get_format_instructions()
48
})
49

50
print(result)
51
# 输出: {'sentiment': '积极', 'reason': '...', 'score': '9'}

1
# pip install langchain
2

3
from langchain_core.output_parsers import BaseOutputParser
4
from typing import List
5

6
class NumberListParser(BaseOutputParser[List[float]]):
7
    """解析模型输出的数字列表（每行一个数字）"""
8

9
    @property
10
    def _type(self) -> str:
11
        return "number_list"
12

13
    def get_format_instructions(self) -> str:
14
        return "请每行输出一个数字，不要包含其他文本。"
15

16
    def parse(self, text: str) -> List[float]:
17
        lines = text.strip().split("\n")
18
        numbers = []
19
        for line in lines:
20
            cleaned = line.strip().strip(".-_ ")
21
            # 提取行中的数字部分
22
            import re
23
            match = re.search(r"[-+]?\d*\.?\d+", cleaned)
24
            if match:
25
                numbers.append(float(match.group()))
26
        return numbers