Les outputs structurés

Résoudre quoi ?

Forcer la sortie LLM au format JSON et le schéma spécifié

Vieilles solutions

Demander au LLM de produire le format JSON et le nom et le type de chaque champ dans le prompt, par exemple :

output in JSON object with follow fileds:
- name: string
- age: number
- isFemale: boolean

LangChain a un analyseur qui peut vous aider à générer des invites.

Question 1 :

Cependant, il y a toujours une probabilité que le LLM produise un format non JSON ou que le champ ne soit pas attendu.

La solution ultérieure

L'API d'OpenAI introduit le mode 'json _ object' qui peut forcer les LLM à retourner au format JSON.

Problème 2

Les champs retournés par le LLM peuvent ne pas être attendus.

Les dernières solutions

Le schéma de sortie structurée d'OpenAI permet d'entrer un schéma JSON explicite dans les champs de l'API afin que le LLM puisse produire le format spécifié.

response_format: { "type": "json_schema", "json_schema": … , "strict": true }

Vous pouvez spécifier le format dans json _ schema, par exemple :

{
        type: "json_schema",
        json_schema: {
            name: "math_response",
            schema: {
                type: "object",
                properties: {
                    steps: {
                        type: "array",
                        items: {
                            type: "object",
                            properties: {
                                explanation: { type: "string" },
                                output: { type: "string" }
                            },
                            required: ["explanation", "output"],
                            additionalProperties: false
                        }
                    },
                    final_answer: { type: "string" }
                },
                required: ["steps", "final_answer"],
                additionalProperties: false
            },
            strict: true
        }
}

Dans Node.js, vous pouvez facilement utiliser :

Définition du schéma JSON

import { z } from "zod";
import { zodResponseFormat } from "openai/helpers/zod";

const Step = z.object({
  explanation: z.string(),
  output: z.string(),
});

const MathResponse = z.object({
  steps: z.array(Step),
  final_answer: z.string(),
});

Dans le champ response _ format

const completion = await openai.beta.chat.completions.parse({
  model: "gpt-4o-mini",
  messages: [
    { role: "system", content: "You are a helpful math tutor. Guide the user through the solution step by step." },
    { role: "user", content: "how can I solve 8x + 7 = -23" },
  ],
  response_format: zodResponseFormat(MathResponse, "math_response"),
});

Très pratique.

• • Comment utiliser dans LangChain * *

import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { z } from "zod";
import { zodResponseFormat } from "openai/helpers/zod";

export async function main() {
  const CalendarEvent = z.object({
    name: z.string(),
    date: z.string(),
    participants: z.array(z.string()),
  });

  const model = new ChatOpenAI({
    model: "gpt-4o-mini",
    // 在这里添加
    modelKwargs: {
      response_format: zodResponseFormat(CalendarEvent, "event"),
    },
  });
  const messages = [
    new SystemMessage("Extract the event information."),
    new HumanMessage("我和小明参加婚礼"),
  ];
  const parser = new StringOutputParser();

  const chain = model.pipe(parser);
  const resp = await chain.invoke(messages);
  console.log(resp);
}

Référencec

官网