How to set response type?

[rossanodr]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

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

const openai = new OpenAI();

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

const completion = await openai.beta.chat.completions.parse({
  model: "gpt-4o-2024-08-06",
  messages: [
    { role: "system", content: "Extract the event information." },
    { role: "user", content: "Alice and Bob are going to a science fair on Friday." },
  ],
  response_format: zodResponseFormat(CalendarEvent, "event"),
});

const event = completion.choices[0].message.parsed;

Description

How can I define the response type to achieve a structured output similar to what OpenAI offers natively?
This is not clear to me. Additionally, is there something similar to the streamObject in Vercel's SDK?
https://sdk.vercel.ai/examples/node/streaming-structured-data/stream-object

System Info

langchain@npm:0.2.20

[dosubot[bot]]

To define the response type for structured output similar to what OpenAI offers natively in LangChain, you can use the createStructuredOutputChainFromZod function. This function allows you to specify a schema using zod, which the model will use to structure its output. Here's an example:

import { z } from "zod";
import { ChatOpenAI } from "@langchain/openai";
import {
  ChatPromptTemplate,
  SystemMessagePromptTemplate,
  HumanMessagePromptTemplate,
} from "@langchain/core/prompts";
import { createStructuredOutputChainFromZod } from "../structured_output.js";

const chain = createStructuredOutputChainFromZod(
  z.object({
    name: z.string().describe("Human name"),
    surname: z.string().describe("Human surname"),
    age: z.number().describe("Human age"),
    appearance: z.string().describe("Human appearance description"),
    shortBio: z.string().describe("Short bio description"),
    university: z.string().optional().describe("University name if attended"),
    gender: z.string().describe("Gender of the human"),
    interests: z
      .array(z.string())
      .describe("json array of strings human interests"),
  }),
  {
    prompt: new ChatPromptTemplate({
      promptMessages: [
        SystemMessagePromptTemplate.fromTemplate(
          "Generate details of a hypothetical person."
        ),
        HumanMessagePromptTemplate.fromTemplate(
          "Person description: {inputText}"
        ),
      ],
      inputVariables: ["inputText"],
    }),
    llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo-0613", temperature: 0 }),
    outputKey: "person",
  }
);

const response = await chain.call({ inputText: "A man, living in Poland." });

For streaming capabilities similar to the streamObject in Vercel's SDK, LangChain provides a streaming method using stream. This allows you to process the output in chunks:

const stream = await chain.stream({});
const chunks = [];
for await (const chunk of stream) {
  chunks.push(chunk);
}

This approach lets you handle the response as it is being generated, similar to streaming objects in other SDKs ^[1].

To continue talking to Dosu, mention @dosu.