LangChain JavaScript

https://docs.langchain.com/oss/javascript/
Admin
LangChain is an open-source framework for building agents and applications powered by LLMs, offering...
Tokens:1,053,297
Snippets:7,884
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install toolchain and start the local development server

Source: https://docs.langchain.com/oss/javascript/contributing/documentation

Installs pinned toolchain dependencies from .mise.toml, sets up repository hooks, and launches the development server with hot reload at http://localhost:3000.

```bash
mise trust && mise install

```

```bash
make install

```

```bash
make dev

```

--------------------------------

### Create a Deep Agent with a weather tool

Source: https://docs.langchain.com/oss/javascript/deepagents/overview

Quickstart example for creating a Deep Agent with a weather tool. Requires installing deepagents, langchain, and @langchain/core. The agent is invoked with a user message asking for the weather in Tokyo.

```javascript
import * as z from "zod";
// npm install deepagents langchain @langchain/core
import { createDeepAgent } from "deepagents";
import { tool } from "langchain";

const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
  name: "get_weather",
  description: "Get the weather for a given city",
  schema: z.object({
    city: z.string(),
  }),
});

const agent = await createDeepAgent({
  tools: [getWeather],
  systemPrompt: "You are a helpful assistant",
});

console.log(
  await agent.invoke({
    messages: [{ role: "user", content: "What's the weather in Tokyo?" }],
  }),
);
```

--------------------------------

### Initialize Composio and get GitHub tools

Source: https://docs.langchain.com/oss/javascript/integrations/tools/composio

Initialize Composio with the LangChain provider and retrieve tools from a specific toolkit (e.g., GitHub). The example logs the number of loaded tools.

```javascript
import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';

// Initialize Composio with LangChain provider
const composio = new Composio({
    apiKey: process.env.COMPOSIO_API_KEY,
    provider: new LangchainProvider(),
});

// Get tools from specific toolkits
const tools = await composio.tools.get('default', 'GITHUB');

console.log(`Loaded ${tools.length} tools from GitHub toolkit`);

```

--------------------------------

### Set up Agent Chat UI by cloning the repository

Source: https://docs.langchain.com/oss/javascript/langchain/ui

Clones the Agent Chat UI repository from GitHub, installs project dependencies, and starts the development server.

```bash
# Clone the repository
git clone https://github.com/langchain-ai/agent-chat-ui.git
cd agent-chat-ui

# Install dependencies and start
pnpm install
pnpm dev

```

--------------------------------

### Install @langchain/deno with npm

Source: https://docs.langchain.com/oss/javascript/integrations/providers/deno

Install the @langchain/deno package using npm.

```bash
npm install @langchain/deno
```

--------------------------------

### Install @langchain/exa with npm

Source: https://docs.langchain.com/oss/javascript/integrations/retrievers/exa

Installs the @langchain/exa and @langchain/core packages using npm.

```bash
npm install @langchain/exa @langchain/core

```

--------------------------------

### Install @langchain/deno with pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/providers/deno

Install the @langchain/deno package using pnpm.

```bash
pnpm add @langchain/deno
```

--------------------------------

### Install @langchain/deno with yarn

Source: https://docs.langchain.com/oss/javascript/integrations/providers/deno

Install the @langchain/deno package using yarn.

```bash
yarn add @langchain/deno
```

--------------------------------

### Install @langchain/google with pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/providers/google

Install the @langchain/google and @langchain/core packages using pnpm.

```bash
pnpm add @langchain/google @langchain/core

```

--------------------------------

### Install @toolbox-sdk/core

Source: https://docs.langchain.com/oss/javascript/integrations/tools/mcp_toolbox

Install the required Node package before using Toolbox with LangChain.

```bash
npm install @toolbox-sdk/core

```

--------------------------------

### Install @langchain/exa with pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/retrievers/exa

Installs the @langchain/exa and @langchain/core packages using pnpm.

```bash
pnpm add @langchain/exa @langchain/core

```

--------------------------------

### Install @langchain/exa with yarn

Source: https://docs.langchain.com/oss/javascript/integrations/retrievers/exa

Installs the @langchain/exa and @langchain/core packages using yarn.

```bash
yarn add @langchain/exa @langchain/core

```

--------------------------------

### Install with pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/embeddings/azure_openai

Install the @langchain/openai package and its core dependency using pnpm.

```bash
pnpm add @langchain/openai @langchain/core
```

--------------------------------

### Install with yarn

Source: https://docs.langchain.com/oss/javascript/integrations/embeddings/azure_openai

Install the @langchain/openai package and its core dependency using yarn.

```bash
yarn add @langchain/openai @langchain/core
```

--------------------------------

### Install @ydbjs/langchain and dependencies

Source: https://docs.langchain.com/oss/javascript/integrations/vectorstores/ydb

Install the required packages for the YDB vector store integration. The guide uses OpenAI embeddings as an example, but other supported embeddings models can be used.

```bash
npm install @ydbjs/langchain @langchain/openai @langchain/core
```

```bash
yarn add @ydbjs/langchain @langchain/openai @langchain/core
```

```bash
pnpm add @ydbjs/langchain @langchain/openai @langchain/core
```

--------------------------------

### Install OpenWiki CLI and initialize repository wiki

Source: https://docs.langchain.com/oss/javascript/deepagents/openwiki

Install OpenWiki globally via npm and initialize documentation for the current repository. Bare openwiki commands default to code mode and output documentation to the openwiki/ directory.

```bash
npm install -g openwiki
openwiki --init

```

--------------------------------

### Install @langchain/classic

Source: https://docs.langchain.com/oss/javascript/deepagents/rag

Install the package needed to use in-memory vector store functionality.

```npm
npm i @langchain/classic

```

```yarn
yarn add @langchain/classic

```

```pnpm
pnpm add @langchain/classic

```

--------------------------------

### Invoke thread-scoped agent with LangGraph SDK

Source: https://docs.langchain.com/oss/javascript/deepagents/going-to-production

Use this client-side code to invoke a thread-scoped agent. Each thread gets its own sandbox, so follow-up messages in the same thread reuse the sandbox, while a new thread starts fresh with no leftover files or installed packages.

```typescript
import { Client } from "@langchain/langgraph-sdk";

const client = new Client({ apiUrl: "<DEPLOYMENT_URL>", apiKey: "<LANGSMITH_API_KEY>" });

// Conversation 1: install pandas and analyze data
const thread1 = await client.threads.create();
for await (const chunk of client.runs.stream(
  thread1.thread_id,
  "agent",
  { input: { messages: [{ role: "human", content: "Install pandas and analyze sales_data.csv" }] } },
)) {
  console.log(chunk.data);
}

// Follow-up in the same conversation — pandas is still installed
for await (const chunk of client.runs.stream(
  thread1.thread_id,
  "agent",
  { input: { messages: [{ role: "human", content: "Now plot the results" }] } },
)) {
  console.log(chunk.data);
}

// Conversation 2: fresh sandbox — pandas is NOT installed, no files from conversation 1
const thread2 = await client.threads.create();
for await (const chunk of client.runs.stream(
  thread2.thread_id,
  "agent",
  { input: { messages: [{ role: "human", content: "What packages are installed?" }] } },
)) {
  console.log(chunk.data);
}
```

--------------------------------

### Install @langchain/openai

Source: https://docs.langchain.com/oss/javascript/integrations/retrievers/sourcey

Install the OpenAI chat model package using npm, yarn, or pnpm. This example uses OpenAI.

```bash
npm install @langchain/openai

```

```bash
yarn add @langchain/openai

```

```bash
pnpm add @langchain/openai

```

--------------------------------

### Install LangGraph CLI

Source: https://docs.langchain.com/oss/javascript/langchain/studio

Run the LangGraph CLI to set up a local development server that connects your agent to Studio.

```bash
npx @langchain/langgraph-cli

```

--------------------------------

### Invoke model with a prompt

Source: https://docs.langchain.com/oss/javascript/langchain/models

Invoke the model with a prompt to get a response. This example follows the model initialization examples and shows the basic call pattern.

```javascript
const response = await model.invoke("Why do parrots talk?");

```

--------------------------------

### Install @langchain/exa and @langchain/core

Source: https://docs.langchain.com/oss/javascript/integrations/tools/exa_search

Install required packages for the Exa search integration using your package manager of choice.

```bash
npm install @langchain/exa @langchain/core

```

```bash
yarn add @langchain/exa @langchain/core

```

```bash
pnpm add @langchain/exa @langchain/core

```

--------------------------------

### Install @langchain/perplexity and @langchain/core

Source: https://docs.langchain.com/oss/javascript/integrations/chat/perplexity

Install the required packages using npm, yarn, or pnpm.

```bash
npm install @langchain/perplexity @langchain/core

```

```bash
yarn add @langchain/perplexity @langchain/core

```

```bash
pnpm add @langchain/perplexity @langchain/core

```

--------------------------------

### Filter tools based on Runtime Context user role

Source: https://docs.langchain.com/oss/javascript/langchain/context-engineering

Filters tools based on the user's role from Runtime Context, using `createMiddleware` with a `contextSchema` that requires `userRole`. Admins get all tools, editors lose `delete_data`, and other roles only get tools starting with `read_`.

```typescript
import * as z from "zod";
import { createMiddleware } from "langchain";

const contextSchema = z.object({
  userRole: z.string(),
});

const contextBasedTools = createMiddleware({
  name: "ContextBasedTools",
  contextSchema,
  wrapModelCall: (request, handler) => {
    // Read from Runtime Context: get user role
    const userRole = request.runtime.context.userRole;

    let filteredTools = request.tools;

    if (userRole === "admin") {
      // Admins get all tools
    } else if (userRole === "editor") {
      filteredTools = request.tools.filter(t => t.name !== "delete_data");
    } else {
      filteredTools = request.tools.filter(t => t.name.startsWith("read_"));
    }

    return handler({ ...request, tools: filteredTools });
  },
});
```

--------------------------------

### docker-compose.yml for local PGVector setup

Source: https://docs.langchain.com/oss/javascript/integrations/vectorstores/pgvector

Defines a local Postgres instance with the pgvector extension using a prebuilt Docker image. Run `docker compose up` to start the database.

```yaml
# Run this command to start the database:
# docker compose up
services:
  db:
    hostname: 127.0.0.1
    image: pgvector/pgvector:pg16
    ports:
      - 5432:5432
    restart: always
    environment:
      - POSTGRES_DB=api
      - POSTGRES_USER=myuser
      - POSTGRES_PASSWORD=ChangeMe

```

--------------------------------

### Install langchain, @langchain/ibm, and @langchain/core

Source: https://docs.langchain.com/oss/javascript/integrations/tools/ibm

Install the required packages for using ChatWatsonx with createAgent. Choose one package manager command.

```bash
npm install langchain @langchain/ibm @langchain/core

```

```bash
yarn add langchain @langchain/ibm @langchain/core

```

```bash
pnpm add langchain @langchain/ibm @langchain/core

```

--------------------------------

### Install @langchain/perplexity with npm, yarn, and pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/retrievers/perplexity_search

Install the required packages for the retriever. Choose the command for your package manager.

```bash
npm install @langchain/perplexity @langchain/core

```

```bash
yarn add @langchain/perplexity @langchain/core

```

```bash
pnpm add @langchain/perplexity @langchain/core

```

--------------------------------

### Pass audio input with input_audio fields

Source: https://docs.langchain.com/oss/javascript/integrations/chat/openai

Pass audio input to the model by specifying `input_audio` fields in a HumanMessage. Reuses the base64 audio data from the first example and the same model instance to get a transcript response.

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

const userInput = new HumanMessage({
  content: [{
    type: "input_audio",
    input_audio: {
      data: castAudioContent.data, // Reuse the base64 data from the first example
      format: "wav",
    },
  }]
})

// Reuse the same model instance
const userInputAudioRes = await modelWithAudioOutput.invoke([userInput]);

console.log((userInputAudioRes.additional_kwargs.audio as Record<string, any>).transcript);
```

```text
That's a great joke! It's always fun to imagine why cats do the funny things they do. Keeping an eye on the "mouse" is a creatively punny way to describe it!
```

--------------------------------

### Install Turbopuffer integration packages

Source: https://docs.langchain.com/oss/javascript/integrations/vectorstores/turbopuffer

Install `@langchain/turbopuffer`, the official `@turbopuffer/turbopuffer` client, `@langchain/core`, and `@langchain/openai` using your preferred package manager.

```bash
npm install @langchain/turbopuffer @turbopuffer/turbopuffer @langchain/core @langchain/openai

```

```bash
yarn add @langchain/turbopuffer @turbopuffer/turbopuffer @langchain/core @langchain/openai

```

```bash
pnpm add @langchain/turbopuffer @turbopuffer/turbopuffer @langchain/core @langchain/openai

```

--------------------------------

### Get logprobs and token usage with ChatOpenAI

Source: https://docs.langchain.com/oss/javascript/integrations/chat/openai

Requires @langchain/core>=0.1.48. Set logprobs to true (and optionally topLogprobs) to receive logprobs in the response_metadata field of the invoke response. The example logs the logprobs object with console.dir.

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

// See https://cookbook.openai.com/examples/using_logprobs for details
const llmWithLogprobs = new ChatOpenAI({
  model: "gpt-5.5",
  logprobs: true,
  // topLogprobs: 5,
});

const responseMessageWithLogprobs = await llmWithLogprobs.invoke("Hi there!");
console.dir(responseMessageWithLogprobs.response_metadata.logprobs, { depth: null });
```

```json
{
  content: [
    {
      token: 'Hello',
      logprob: -0.0004740447,
      bytes: [ 72, 101, 108, 108, 111 ],
      top_logprobs: []
    },
    {
      token: '!',
      logprob: -0.00004334534,
      bytes: [ 33 ],
      top_logprobs: []
    },
    {
      token: ' How',
      logprob: -0.000030113732,
      bytes: [ 32, 72, 111, 119 ],
      top_logprobs: []
    },
    {
      token: ' can',
      logprob: -0.0004797665,
      bytes: [ 32, 99, 97, 110 ],
      top_logprobs: []
    },
    {
      token: ' I',
      logprob: -7.89631e-7,
      bytes: [ 32, 73 ],
      top_logprobs: []
    },
    {
      token: ' assist',
      logprob: -0.114006,
      bytes: [
         32,  97, 115,
        115, 105, 115,
        116
      ],
      top_logprobs: []
    },
    {
      token: ' you',
      logprob: -4.3202e-7,
      bytes: [ 32, 121, 111, 117 ],
      top_logprobs: []
    },
    {
      token: ' today',
      logprob: -0.00004501419,
      bytes: [ 32, 116, 111, 100, 97, 121 ],
      top_logprobs: []
    },
    {
      token: '?',
      logprob: -0.000010206721,
      bytes: [ 63 ],
      top_logprobs: []
    }
  ],
  refusal: null
}
```

--------------------------------

### Use TavilyGetResearch and TavilyResearch in an agent

Source: https://docs.langchain.com/oss/javascript/integrations/tools/tavily_get_research

Use both Tavily research tools within a LangChain agent. The agent can start a research task and retrieve results by request ID. This example shows streaming events and tool calls.

```javascript
import { ChatOpenAI } from "@langchain/openai";
import { TavilyGetResearch, TavilyResearch } from "@langchain/tavily";
import { createAgent } from "langchain";

const llm = new ChatOpenAI({
  model: "gpt-5.5",
});

const agent = createAgent({
  model: llm,
  tools: [
    new TavilyResearch({
      model: "mini",
    }),
    new TavilyGetResearch(),
  ],
});

const userInput =
  "Start a research task on AI agents, then retrieve the results when ready.";

const stream = await agent.streamEvents(
  { messages: [{ role: "user", content: userInput }] },
  { version: "v3" },
);

await Promise.all([
  (async () => {
    for await (const message of stream.messages) {
      for await (const token of message.text) {
        process.stdout.write(token);
      }
    }
  })(),
  (async () => {
    for await (const call of stream.toolCalls) {
      console.dir({ name: call.name, input: call.input }, { depth: null });
      await call.output;
    }
  })(),
]);

await stream.output;

```

--------------------------------

### Install @composio/langchain and @composio/core with npm

Source: https://docs.langchain.com/oss/javascript/integrations/tools/composio

Install the Composio LangChain integration packages using npm.

```bash
npm install @composio/langchain @composio/core

```

--------------------------------

### Install ChatGroq integration packages

Source: https://docs.langchain.com/oss/javascript/integrations/chat/groq

Install the necessary `@langchain/groq` and `@langchain/core` dependencies using npm, yarn, or pnpm.

```npm
npm install @langchain/groq @langchain/core

```

```yarn
yarn add @langchain/groq @langchain/core

```

```pnpm
pnpm add @langchain/groq @langchain/core

```

--------------------------------

### Use Composio tools with GitHub toolkit to star a repository

Source: https://docs.langchain.com/oss/javascript/integrations/tools/composio

Example that stars a GitHub repository using Composio tools with a LangGraph agent. It initializes Composio, gets GitHub tools, creates a ChatOpenAI model, and uses createReactAgent to execute the task.

```javascript
import { ChatOpenAI } from '@langchain/openai';
import { createReactAgent } from '@langchain/langgraph/prebuilt';
import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';

// Initialize Composio
const composio = new Composio({
    apiKey: process.env.COMPOSIO_API_KEY,
    provider: new LangchainProvider(),
});

// Get GitHub tools
const tools = await composio.tools.get('default', 'GITHUB');

// Create model
const model = new ChatOpenAI({
    model: 'gpt-5',
});

// Create agent
const agent = createReactAgent({
    llm: model,
    tools: tools,
});

// Execute task
const result = await agent.invoke({
    messages: [
        {
            role: 'user',
            content: 'Star the repository composiohq/composio on GitHub'
        }
    ]
});

console.log(result.messages[result.messages.length - 1].content);

```

--------------------------------

### Build a basic agent with OpenAI

Source: https://docs.langchain.com/oss/javascript/langchain/quickstart

Initializes a LangChain agent using the OpenAI gpt-5.5 model and a weather tool, then invokes it with a user prompt.

```javascript
import { createAgent, tool } from "langchain";
import * as z from "zod";

const getWeather = tool(
  (input) => `It's always sunny in ${input.city}!Original`,
  {
    name: "get_weather",
    description: "Get the weather for a given city",
    schema: z.object({
      city: z.string().describe("The city to get the weather for"),
    }),
  }
);

const agent = createAgent({
  model: "gpt-5.5",
  tools: [getWeather],
});

console.log(
  await agent.invoke({
    messages: [{ role: "user", content: "What's the weather in San Francisco?" }],
  })
);
```

--------------------------------

### Launch MCP server as subprocess via stdio

Source: https://docs.langchain.com/oss/javascript/langchain/mcp-v1

Use the 'stdio' transport to launch a server as a subprocess and communicate via standard input/output. Best for local tools and simple setups. The example uses the 'node' command with a path to a JavaScript server file.

```typescript
const client = new MultiServerMCPClient({
    math: {
        transport: "stdio",
        command: "node",
        args: ["/path/to/math_server.js"],
    },
});

```

--------------------------------

### Rerank with scores using similaritySearchWithScore

Source: https://docs.langchain.com/oss/javascript/integrations/vectorstores/sap_hanavector

Use `similaritySearchWithScore` with a `RerankConfigOptions` object to get reranking scores along with the documents. The example configures `modelId` from `HANA_DB_RERANKING_MODEL_ID` (defaulting to `SAP_CER.20250701`) and `topN: 3`. The output shows the scores and content for the top 3 reranked results.

```typescript
const rerankConfigWithScores: RerankConfigOptions = {
  modelId: process.env.HANA_DB_RERANKING_MODEL_ID || "SAP_CER.20250701",
  topN: 3,
};

const docsRerankedwithScores = await vectorStore.similaritySearchWithScore("neural network architecture", 3, undefined, undefined, rerankConfigWithScores);
console.log("Reranked results with scores:");
docsRerankedwithScores.forEach(([doc, score]) => {
  console.log("-".repeat(80));
  console.log("Score:", score.toFixed(4));
  console.log(`Content: ${doc.pageContent}`);
});
```

```text
Reranked results with scores:
--------------------------------------------------------------------------------
Score: 0.0435
Content: Neural networks are inspired by the human brain
--------------------------------------------------------------------------------
Score: 0.0146
Content: Python is a programming language
--------------------------------------------------------------------------------
Score: 0.0145
Content: Machine learning uses algorithms to learn patterns
```

--------------------------------

### Enable task planning with todoListMiddleware for each provider

Source: https://docs.langchain.com/oss/javascript/deepagents/overview

Enable task planning by passing todoListMiddleware() to createDeepAgent. Each variant uses a different model provider (Google, OpenAI, Anthropic, OpenRouter, Fireworks, Baseten, Ollama) with the same middleware setup. Task planning is opt-in starting in v0.7; earlier versions included it by default.

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "google:gemini-3.6-flash",
  middleware: [todoListMiddleware()],
});

```

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  middleware: [todoListMiddleware()],
});

```

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-5",
  middleware: [todoListMiddleware()],
});

```

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "openrouter:z-ai/glm-5.2",
  middleware: [todoListMiddleware()],
});

```

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  middleware: [todoListMiddleware()],
});

```

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  middleware: [todoListMiddleware()],
});

```

```typescript
import { createDeepAgent } from "deepagents";
import { todoListMiddleware } from "langchain";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  middleware: [todoListMiddleware()],
});

```

--------------------------------

### Install @langchain/azure with bun

Source: https://docs.langchain.com/oss/javascript/langchain/multi-agent/router-knowledge-base

Install the Azure chat model integration package using bun.

```bash
bun add @langchain/azure

```

--------------------------------

### Install project dependencies

Source: https://docs.langchain.com/oss/javascript/langgraph/local-server

Run npm install in the root directory of your LangGraph app to install dependencies in edit mode for local development.

```bash
cd path/to/your/app
npm install

```

--------------------------------

### Install @langchain/mcp-adapters with npm, pnpm, yarn, or bun

Source: https://docs.langchain.com/oss/javascript/langchain/mcp-v1

Install the @langchain/mcp-adapters library version 1.x using your preferred package manager. Choose the command that matches your environment (npm, pnpm, yarn, or bun).

```bash
npm install @langchain/mcp-adapters@^1

```

```bash
pnpm add @langchain/mcp-adapters@^1

```

```bash
yarn add @langchain/mcp-adapters@^1

```

```bash
bun add @langchain/mcp-adapters@^1

```

--------------------------------

### Install LangChain package

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Installs LangChain to access LLMs and define tools. Specific LLM provider integrations must be installed separately.

```bash
npm install langchain

```

```bash
pnpm add langchain

```

```bash
yarn add langchain

```

```bash
bun add langchain

```

--------------------------------

### Install @composio/langchain and @composio/core with Yarn or pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/tools/composio

Install the Composio LangChain integration packages using Yarn or pnpm.

```bash
yarn add @composio/langchain @composio/core
# or
pnpm add @composio/langchain @composio/core

```

--------------------------------

### Install @langchain/openrouter and @langchain/core

Source: https://docs.langchain.com/oss/javascript/integrations/chat/openrouter

Install the required OpenRouter integration and core packages using your preferred package manager.

```bash
npm install @langchain/openrouter @langchain/core

```

```bash
yarn add @langchain/openrouter @langchain/core

```

```bash
pnpm add @langchain/openrouter @langchain/core

```

--------------------------------

### Install @langchain/modal with npm, yarn, or pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/providers/modal

Install the @langchain/modal package using npm, yarn, or pnpm. These are alternative package manager commands for the same installation.

```bash
npm install @langchain/modal
```

```bash
yarn add @langchain/modal
```

```bash
pnpm add @langchain/modal
```

--------------------------------

### Install @clicksend/langchain-clicksend-mcp

Source: https://docs.langchain.com/oss/javascript/integrations/tools/clicksend

Install the ClickSend LangChain integration package.

```bash
npm install @clicksend/langchain-clicksend-mcp
```

--------------------------------

### Install @langchain/groq with npm, yarn, or pnpm

Source: https://docs.langchain.com/oss/javascript/integrations/chat

Install the LangChain Groq integration and core packages using npm, yarn, or pnpm.

```bash
npm install @langchain/groq @langchain/core
```

```bash
yarn add @langchain/groq @langchain/core
```

```bash
pnpm add @langchain/groq @langchain/core
```

--------------------------------

### Install @langchain/jigsawstack

Source: https://docs.langchain.com/oss/javascript/integrations/llms/jigsawstack

Installs the LangChain JigsawStack integration package.

```bash
npm install @langchain/jigsawstack
```

--------------------------------

### Install langchain and @langchain/core

Source: https://docs.langchain.com/oss/javascript/integrations/stores/file_system

Install the langchain and @langchain/core packages using npm, yarn, or pnpm. The LocalFileStore integration lives in the langchain package.

```bash
npm install langchain @langchain/core
```

```bash
yarn add langchain @langchain/core
```

```bash
pnpm add langchain @langchain/core
```
Tokens:
Raw