Dans le paysage en constante évolution de l'IA et du machine learning, obtenir des données structurées à partir de modèles de chat est primordial pour intégrer ces modèles de manière fluide dans diverses applications. LangChain, une bibliothèque réputée en IA, offre des outils et méthodes robustes pour obtenir des sorties de données structurées de manière transparente. Que vous soyez un développeur chevronné ou que vous débutiez votre parcours, ce tutoriel vous guidera dans le processus de transformation de sorties textuelles arbitraires en données structurées en utilisant LangChain.

Embarquons dans ce voyage pour maîtriser la sortie de données structurées avec LangChain, en découvrant des stratégies et techniques conçues pour améliorer vos capacités.

Prérequis : Ce guide suppose une compréhension basique des modèles de chat et de la méthode .withStructuredOutput().

Pourquoi la sortie de données structurées ?

Les données structurées vous permettent de mapper les sorties textuelles dans des schémas prédéfinis, leur permettant de s'intégrer de manière transparente dans les bases de données et autres systèmes en aval. Ce tutoriel démontrera plusieurs stratégies pour y parvenir avec LangChain.

Installation initiale

D'abord, nous devons installer les dépendances nécessaires. Selon votre fournisseur de modèle préféré, vos commandes d'installation varieront :

OpenAI

npm i @langchain/openai

import { ChatOpenAI } from "@langchain/openai";
 
const model = new ChatOpenAI({ model: "gpt-3.5-turbo", temperature: 0 });

Anthropic

npm i @langchain/anthropic

import { ChatAnthropic } from "@langchain/anthropic";
 
const model = new ChatAnthropic({ model: "claude-3-sonnet-20240229", temperature: 0 });

Configuration initiale

N'oubliez pas de définir vos variables d'environnement avec vos clés API :

OPENAI_API_KEY=your-api-key
ANTHROPIC_API_KEY=your-api-key

Définition de schéma avec Zod

Pour faciliter la sortie de données structurées, nous pouvons exploiter Zod, une bibliothèque de déclaration et validation de schéma TypeScript-first. Voici un exemple simple de définition d'un schéma pour une blague :

import { z } from "zod";
 
const joke = z.object({
  setup: z.string().describe("The setup of the joke"),
  punchline: z.string().describe("The punchline to the joke"),
  rating: z.number().optional().describe("How funny the joke is, from 1 to 10"),
});

Intégration avec LangChain

En utilisant .withStructuredOutput(), intégrons ce schéma avec notre modèle :

const structuredLlm = model.withStructuredOutput(joke);
 
await structuredLlm.invoke("Tell me a joke about cats");
// Expected Output:
// { setup: "Why don't cats play poker in the wild?", punchline: "Too many cheetahs.", rating: 7 }

Nommage du schéma pour un meilleur contexte

Ajouter un nom à votre schéma peut fournir un contexte supplémentaire au modèle, améliorant ses performances :

const structuredLlm = model.withStructuredOutput(joke, { name: "joke" });
 
await structuredLlm.invoke("Tell me a joke about cats");
// Expected Output:
// { setup: "Why don't cats play poker in the wild?", punchline: "Too many cheetahs!", rating: 7 }

Utilisation du schéma JSON

Pour ceux qui préfèrent ne pas utiliser Zod, LangChain supporte également le schéma JSON de style OpenAI :

const structuredLlm = model.withStructuredOutput({
  name: "joke",
  description: "Joke to tell user.",
  parameters: {
    title: "Joke",
    type: "object",
    properties: {
      setup: { type: "string", description: "The setup for the joke" },
      punchline: { type: "string", description: "The joke's punchline" },
    },
    required: ["setup", "punchline"],
  },
});
 
await structuredLlm.invoke("Tell me a joke about cats");
// Expected Output:
// { setup: "Why was the cat sitting on the computer?", punchline: "Because it wanted to keep an eye on the mouse!" }

Spécification de sortie avancée

Pour les modèles supportant plusieurs méthodologies de sortie, spécifiez votre préférence :

const structuredLlm = model.withStructuredOutput(joke, { method: "json_mode", name: "joke" });
 
await structuredLlm.invoke("Tell me a joke about cats, respond in JSON with `setup` and `punchline` keys");
// Expected Output:
// { setup: "Why don't cats play poker in the jungle?", punchline: "Too many cheetahs!" }

Techniques de prompting

Pour les modèles qui ne supportent pas les capacités de sortie structurée intégrées, des prompts bien conçus peuvent inciter les modèles à produire des données dans des formats structurés. En exploitant le JsonOutputParser, démontrons ceci :

import { JsonOutputParser } from "@langchain/core/output_parsers";
import { ChatPromptTemplate } from "@langchain/core/prompts";
 
type Person = { name: string; height_in_meters: number; };
type People = { people: Person[]; };
 
const formatInstructions = `
Respond only in valid JSON. The JSON object you return should match the following schema:
{ people: [{ name: "string", height_in_meters: "number" }] }
Where people is an array of objects, each with a name and height_in_meters field.
`;
 
// Set up a parser
const parser = new JsonOutputParser();
 
// Create the prompt template
const prompt = await ChatPromptTemplate.fromMessages([
  ["system", "Answer the user query. Wrap the output in `json` tags\n{format_instructions}"],
  ["human", "{query}"]
]).partial({ format_instructions: formatInstructions });

Parsing personnalisé avec LangChain

Si les solutions intégrées ne correspondent pas à votre cas d'usage, le parsing personnalisé utilisant LangChain Expression Language (LCEL) peut être ce dont vous avez besoin :

import { AIMessage } from "@langchain/core/messages";
import { ChatPromptTemplate } from "@langchain/core/prompts";
 
type Person = { name: string; height_in_meters: number; };
type People = { people: Person[]; };
 
const schema = `
{ people: [{ name: "string", height_in_meters: "number" }] }
`;
 
// Creating the prompt template
const prompt = await ChatPromptTemplate.fromMessages([
  ["system", `Answer the user query. Output your answer as JSON that matches the given schema: \`\`\`json\n{schema}\n\`\`\`. Make sure to wrap the answer in \`\`\`json and \`\`\` tags`],
  ["human", "{query}"]
]).partial({ schema });
 
// Custom extractor to parse JSON from AI output
const extractJson = (output: AIMessage): Array => {
  const text = output.content as string;
  const pattern = /```json(.*?)```/gs;
  const matches = text.match(pattern);
 
  try {
    return (matches?.map(match => {
      const jsonStr = match.replace(/```json|```/g, "").trim();
      return JSON.parse(jsonStr);
    }) ?? []);
  } catch (error) {
    throw new Error(`Failed to parse: ${output}`);
  }
};
 
// Invoke the parsing chain
const query = "Anna is 23 years old and she is 6 feet tall";
const chain = prompt.pipe(model).pipe(new RunnableLambda({ func: extractJson }));
 
await chain.invoke({ query });
// Expected Output:
// [ { people: [ { name: "Anna", height_in_meters: 1.83 } ] } ]

Résumé

Dans ce tutoriel, nous avons exploré plusieurs méthodes pour assurer que vos modèles de chat produisent des données structurées en utilisant LangChain. Armé de ces connaissances, vous pouvez maintenant intégrer ces modèles plus efficacement dans vos applications, fournissant des sorties raffinées et structurées qui correspondent à vos besoins.

Pour lire des guides plus détaillés sur la sortie structurée et d'autres techniques avancées, veuillez visiter la documentation officielle de LangChain.

Auteur : Équipe de documentation LangChain

Explorez la puissance de la sortie de données structurées avec LangChain. Transformez la façon dont vous gérez les sorties IA dès aujourd'hui ! En savoir plus ici.

Maîtriser la sortie de données structurées avec LangChain : Stratégies et techniques pour les modèles de chat