OutputParserException: Failed to parse LLM output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from langchain.prompts import PromptTemplate
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field

class Answer(BaseModel):
    answer: str = Field(description="The answer to the question")
    confidence: float = Field(description="Confidence score between 0 and 1")

parser = PydanticOutputParser(pydantic_object=Answer)

prompt = PromptTemplate(
    template="""Answer the question.

{format_instructions}

Question: {question}

Remember: You MUST respond with valid JSON only, no additional text.""",
    input_variables=["question"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from langchain.output_parsers import RetryWithErrorOutputParser

retry_parser = RetryWithErrorOutputParser.from_llm(
    parser=parser,
    llm=llm,
    max_retries=3
)

# パース失敗時に自動リトライ
result = retry_parser.parse_with_prompt(output, prompt_value)

1
2
3
4
5
6
7
8
9

from langchain.output_parsers import OutputFixingParser

fixing_parser = OutputFixingParser.from_llm(
    parser=parser,
    llm=llm
)

# 不正な出力を自動修正
result = fixing_parser.parse(malformed_output)

1
2
3
4
5
6
7
8

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4-turbo",
    model_kwargs={"response_format": {"type": "json_object"}}
)

# JSONモードではJSON出力が保証される

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from langchain_core.pydantic_v1 import BaseModel

class Joke(BaseModel):
    setup: str
    punchline: str

# with_structured_outputを使用
structured_llm = llm.with_structured_output(Joke)
result = structured_llm.invoke("Tell me a joke")
# resultはJoke型で返される

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from langchain.schema.output_parser import OutputParserException

try:
    result = parser.parse(llm_output)
except OutputParserException as e:
    # フォールバック処理
    print(f"Parse error: {e}")

    # 生のテキストとして扱う
    result = {"raw_text": llm_output, "parsed": False}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from langchain.output_parsers import RegexParser

# JSON抽出用の正規表現
regex_parser = RegexParser(
    regex=r'\{[\s\S]*\}',
    output_keys=["json_content"]
)

# JSONブロックを抽出
json_str = regex_parser.parse(output)["json_content"]
result = json.loads(json_str)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import re
import json

def extract_json(text: str) -> dict:
    # ```json ... ``` ブロックを抽出
    pattern = r'```(?:json)?\s*([\s\S]*?)\s*```'
    match = re.search(pattern, text)

    if match:
        return json.loads(match.group(1))

    # 直接JSONとしてパース
    return json.loads(text)