Chat Models

import { BaseChatModel } from "@langchain/core/language_models/chat_models";

import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-4o",
  temperature: 0.7,
  maxTokens: 500
});

const response = await model.invoke([
  ["system", "You are a helpful assistant"],
  ["human", "Tell me a joke"]
]);

console.log(response.content);

const stream = await model.stream([
  ["human", "Write a poem about the ocean"]
]);

for await (const chunk of stream) {
  console.log(chunk.content);
}

import { tool } from "@langchain/core/tools";
import { z } from "zod";

const calculator = tool(
  async ({ expression }) => {
    return String(eval(expression));
  },
  {
    name: "calculator",
    description: "Evaluate a mathematical expression",
    schema: z.object({
      expression: z.string().describe("The expression to evaluate")
    })
  }
);

const modelWithTools = model.bindTools([calculator]);

const response = await modelWithTools.invoke([
  ["human", "What's 25 * 4?"]
]);

if (response.tool_calls && response.tool_calls.length > 0) {
  console.log("Tool calls:", response.tool_calls);
}

import { z } from "zod";

const schema = z.object({
  name: z.string(),
  age: z.number(),
  email: z.string().email()
});

const structuredModel = model.withStructuredOutput(schema);

const result = await structuredModel.invoke([
  ["human", "Extract info: John Doe is 30 years old. Email: [email protected]"]
]);

console.log(result);
// { name: "John Doe", age: 30, email: "[email protected]" }

const responses = await model.batch([
  [["human", "What is 2+2?"]],
  [["human", "What is 3+3?"]],
  [["human", "What is 4+4?"]]
]);

responses.forEach((response, i) => {
  console.log(`Response ${i + 1}:`, response.content);
});

const response = await model.invoke([["human", "Hi"]]);

console.log(response.response_metadata);
// {
//   model_name: "gpt-4o",
//   finish_reason: "stop",
//   usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 }
// }

import { BaseChatModel } from "@langchain/core/language_models/chat_models";
import { AIMessage } from "@langchain/core/messages";

class CustomChatModel extends BaseChatModel {
  _llmType() {
    return "custom";
  }

  async _generate(
    messages: BaseMessage[],
    options?: this["ParsedCallOptions"]
  ): Promise<ChatResult> {
    // Your implementation
    return {
      generations: [{
        message: new AIMessage("Custom response"),
        text: "Custom response"
      }]
    };
  }
}