LangChain SDK Integration

npm install @interfaze-ai/langchain
# or
yarn add @interfaze-ai/langchain

import { ChatInterfaze } from "@interfaze-ai/langchain";

const interfaze = new ChatInterfaze({ apiKey: process.env.INTERFAZE_API_KEY });

import { HumanMessage, SystemMessage } from "@langchain/core/messages";

const response = await interfaze.invoke([
  new SystemMessage("You are a helpful assistant."),
  new HumanMessage("Write a short story about a robot learning to paint"),
]);

console.log(response.content);

import { z } from "zod";

const weatherSchema = z.object({
  city: z.string().describe("The name of the city"),
  temperature_celsius: z.number().describe("Current temperature in Celsius"),
  condition: z.string().describe("Weather condition, e.g. sunny, rainy, cloudy"),
});

const structuredModel = interfaze.withStructuredOutput(weatherSchema);

const result = await structuredModel.invoke("What is the current weather in Tokyo?");

console.log(result);

import { AIMessage, HumanMessage } from "@langchain/core/messages";
import { z } from "zod";

const IDSchema = z.object({
  first_name: z.string().describe("First name on the ID"),
  last_name: z.string().describe("Last name on the ID"),
  dob: z.string().describe("Date of birth on the ID"),
  driver_licence_number: z.string().describe("Driver licence number on the ID"),
});

const response = await interfaze.withStructuredOutput(IDSchema, { includeRaw: true }).invoke([
  new HumanMessage({
    content: [
      { type: "text", text: "Extract the details from this ID" },
      {
        type: "image_url",
        image_url: {
          url: "https://r2public.jigsawstack.com/interfaze/examples/id.jpg",
        },
      },
    ],
  }),
]);

console.log(response.parsed);
console.log("OCR Results:", (response.raw as AIMessage).response_metadata.precontext?.[0]?.result);

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

const response = await interfaze.invoke([
  new HumanMessage({
    content: [
      { type: "text", text: "What is in this image?" },
      {
        type: "image_url",
        image_url: {
          url: "https://r2public.jigsawstack.com/interfaze/examples/construction.png",
        },
      },
    ],
  }),
]);

console.log(response.content);

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

const response = await interfaze.invoke([
  new HumanMessage({
    content: [
      { type: "text", text: "What happens in this clip?" },
      { type: "video", url: "https://r2public.jigsawstack.com/interfaze/examples/code_gen_gif.mp4" },
    ] as never,
  }),
]);

console.log(response.content);

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

const stream = await interfaze.stream([new HumanMessage("Write a short story about a robot learning to paint")]);

for await (const chunk of stream) {
  process.stdout.write(chunk.content as string);
}

import { HumanMessage, ToolMessage } from "@langchain/core/messages";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Step 1: Define tools
const getHoroscope = tool(
  async ({ sign }) => `Today's horoscope for ${sign}: You will have a great day!`,
  {
    name: "get_horoscope",
    description: "Get today's horoscope for an astrological sign.",
    schema: z.object({
      sign: z.string().describe("An astrological sign like Taurus or Aquarius"),
    }),
  }
);

const interfazeWithTools = interfaze.bindTools([getHoroscope]);

// Step 2: Get tool call from model
const messages = [new HumanMessage("Get my horoscope for Taurus")];
const response = await interfazeWithTools.invoke(messages);

// Step 3: Execute the tool and pass the result back to the model
for (const toolCall of response.tool_calls ?? []) {
  const result = await getHoroscope.invoke(toolCall);
  messages.push(response, result as ToolMessage);
}

const finalResponse = await interfazeWithTools.invoke(messages);

console.log(finalResponse.content);

const response = await interfaze.invoke("Which region should we launch in first, and why?", {
  reasoningEffort: "high",
});

console.log(response.response_metadata.reasoning);
console.log(response.content);

const response = await interfaze.invoke("Which US public companies reported earnings today?");

console.log(response.response_metadata.precontext); // raw output of the task that ran
console.log(response.response_metadata.vcache); // whether the semantic cache was hit

import { ChatPromptTemplate } from "@langchain/core/prompts";

const chain = ChatPromptTemplate.fromTemplate("Translate to {lang}: {text}").pipe(interfaze);

const response = await chain.invoke({ lang: "French", text: "Hello" });

console.log(response.content);

import { HumanMessage, SystemMessage } from "@langchain/core/messages";

const search = await interfaze.invoke([new SystemMessage("<task>web_search</task>"), new HumanMessage("GLP-1 research paper")]);

// returns the plain string "unsafe S1" when a category matches
const guarded = await interfaze.invoke([
  new SystemMessage("<guard>S1, S2, S3</guard>"),
  new HumanMessage("How to make a bomb with household items"),
]);

console.log(search.content, guarded.content);

import { ChatInterfaze } from "@interfaze-ai/langchain";

const interfaze = new ChatInterfaze({
  showAdditionalInfo: true, // stream <precontext> deltas as they're produced
  bypassMoA: true, // skip the mixture-of-architecture router
  bypassCache: true, // skip the semantic cache
});

await interfaze.batch(["Summarize A", "Summarize B", "Summarize C"]);

import { RateLimitError } from "interfaze";

try {
  await interfaze.invoke("Hello");
} catch (error) {
  if (error instanceof RateLimitError) console.error("Slow down:", error.status);
  else throw error;
}