AzureChatOpenAI

import { AzureChatOpenAI } from '@langchain/openai';

const llm = new AzureChatOpenAI({
  azureOpenAIApiKey: process.env.AZURE_OPENAI_API_KEY, // In Node.js defaults to process.env.AZURE_OPENAI_API_KEY
  azureOpenAIApiInstanceName: process.env.AZURE_OPENAI_API_INSTANCE_NAME, // In Node.js defaults to process.env.AZURE_OPENAI_API_INSTANCE_NAME
  azureOpenAIApiDeploymentName: process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME, // In Node.js defaults to process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME
  azureOpenAIApiVersion: process.env.AZURE_OPENAI_API_VERSION, // In Node.js defaults to process.env.AZURE_OPENAI_API_VERSION
  temperature: 0,
  maxTokens: undefined,
  timeout: undefined,
  maxRetries: 2,
  // apiKey: "...",
  // baseUrl: "...",
  // other params...
});

const input = `Translate "I love programming" into French.`;

// Models also accept a list of chat messages or a formatted prompt
const result = await llm.invoke(input);
console.log(result);

AIMessage {
  "id": "chatcmpl-9u4Mpu44CbPjwYFkTbeoZgvzB00Tz",
  "content": "J'adore la programmation.",
  "response_metadata": {
    "tokenUsage": {
      "completionTokens": 5,
      "promptTokens": 28,
      "totalTokens": 33
    },
    "finish_reason": "stop",
    "system_fingerprint": "fp_3aa7262c27"
  },
  "usage_metadata": {
    "input_tokens": 28,
    "output_tokens": 5,
    "total_tokens": 33
  }
}

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

AIMessageChunk {
  "id": "chatcmpl-9u4NWB7yUeHCKdLr6jP3HpaOYHTqs",
  "content": ""
}
AIMessageChunk {
  "content": "J"
}
AIMessageChunk {
  "content": "'adore"
}
AIMessageChunk {
  "content": " la"
}
AIMessageChunk {
  "content": " programmation",,
}
AIMessageChunk {
  "content": ".",,
}
AIMessageChunk {
  "content": "",
  "response_metadata": {
    "finish_reason": "stop",
    "system_fingerprint": "fp_c9aa9c0491"
  },
}
AIMessageChunk {
  "content": "",
  "usage_metadata": {
    "input_tokens": 28,
    "output_tokens": 5,
    "total_tokens": 33
  }
}

import { AIMessageChunk } from '@langchain/core/messages';
import { concat } from '@langchain/core/utils/stream';

const stream = await llm.stream(input);
let full: AIMessageChunk | undefined;
for await (const chunk of stream) {
  full = !full ? chunk : concat(full, chunk);
}
console.log(full);

AIMessageChunk {
  "id": "chatcmpl-9u4PnX6Fy7OmK46DASy0bH6cxn5Xu",
  "content": "J'adore la programmation.",
  "response_metadata": {
    "prompt": 0,
    "completion": 0,
    "finish_reason": "stop",
  },
  "usage_metadata": {
    "input_tokens": 28,
    "output_tokens": 5,
    "total_tokens": 33
  }
}

import { z } from 'zod';

const GetWeather = {
  name: "GetWeather",
  description: "Get the current weather in a given location",
  schema: z.object({
    location: z.string().describe("The city and state, e.g. San Francisco, CA")
  }),
}

const GetPopulation = {
  name: "GetPopulation",
  description: "Get the current population in a given location",
  schema: z.object({
    location: z.string().describe("The city and state, e.g. San Francisco, CA")
  }),
}

const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
const aiMsg = await llmWithTools.invoke(
  "Which city is hotter today and which is bigger: LA or NY?"
);
console.log(aiMsg.tool_calls);

[
  {
    name: 'GetWeather',
    args: { location: 'Los Angeles, CA' },
    type: 'tool_call',
    id: 'call_uPU4FiFzoKAtMxfmPnfQL6UK'
  },
  {
    name: 'GetWeather',
    args: { location: 'New York, NY' },
    type: 'tool_call',
    id: 'call_UNkEwuQsHrGYqgDQuH9nPAtX'
  },
  {
    name: 'GetPopulation',
    args: { location: 'Los Angeles, CA' },
    type: 'tool_call',
    id: 'call_kL3OXxaq9OjIKqRTpvjaCH14'
  },
  {
    name: 'GetPopulation',
    args: { location: 'New York, NY' },
    type: 'tool_call',
    id: 'call_s9KQB1UWj45LLGaEnjz0179q'
  }
]

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().nullable().describe("How funny the joke is, from 1 to 10")
}).describe('Joke to tell user.');

const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
console.log(jokeResult);

{
  setup: 'Why was the cat sitting on the computer?',
  punchline: 'Because it wanted to keep an eye on the mouse!',
  rating: 7
}

const jsonLlm = llm.withConfig({ response_format: { type: "json_object" } });
const jsonLlmAiMsg = await jsonLlm.invoke(
  "Return a JSON object with key 'randomInts' and a value of 10 random ints in [0-99]"
);
console.log(jsonLlmAiMsg.content);

{
  "randomInts": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]
}

import { HumanMessage } from '@langchain/core/messages';

const imageUrl = "https://example.com/image.jpg";
const imageData = await fetch(imageUrl).then(res => res.arrayBuffer());
const base64Image = Buffer.from(imageData).toString('base64');

const message = new HumanMessage({
  content: [
    { type: "text", text: "describe the weather in this image" },
    {
      type: "image_url",
      image_url: { url: `data:image/jpeg;base64,${base64Image}` },
    },
  ]
});

const imageDescriptionAiMsg = await llm.invoke([message]);
console.log(imageDescriptionAiMsg.content);

The weather in the image appears to be clear and sunny. The sky is mostly blue with a few scattered white clouds, indicating fair weather. The bright sunlight is casting shadows on the green, grassy hill, suggesting it is a pleasant day with good visibility. There are no signs of rain or stormy conditions.

const aiMsgForMetadata = await llm.invoke(input);
console.log(aiMsgForMetadata.usage_metadata);

{ input_tokens: 28, output_tokens: 5, total_tokens: 33 }

const logprobsLlm = new ChatOpenAI({ model: "gpt-4o-mini", logprobs: true });
const aiMsgForLogprobs = await logprobsLlm.invoke(input);
console.log(aiMsgForLogprobs.response_metadata.logprobs);

{
  content: [
    {
      token: 'J',
      logprob: -0.000050616763,
      bytes: [Array],
      top_logprobs: []
    },
    {
      token: "'",
      logprob: -0.01868736,
      bytes: [Array],
      top_logprobs: []
    },
    {
      token: 'ad',
      logprob: -0.0000030545007,
      bytes: [Array],
      top_logprobs: []
    },
    { token: 'ore', logprob: 0, bytes: [Array], top_logprobs: [] },
    {
      token: ' la',
      logprob: -0.515404,
      bytes: [Array],
      top_logprobs: []
    },
    {
      token: ' programm',
      logprob: -0.0000118755715,
      bytes: [Array],
      top_logprobs: []
    },
    { token: 'ation', logprob: 0, bytes: [Array], top_logprobs: [] },
    {
      token: '.',
      logprob: -0.0000037697225,
      bytes: [Array],
      top_logprobs: []
    }
  ],
  refusal: null
}

const aiMsgForResponseMetadata = await llm.invoke(input);
console.log(aiMsgForResponseMetadata.response_metadata);

{
  tokenUsage: { completionTokens: 5, promptTokens: 28, totalTokens: 33 },
  finish_reason: 'stop',
  system_fingerprint: 'fp_3aa7262c27'
}