open-index/open-npm huggingface dataset:
npm package: @langazov/ngx-remote-desktop
Description: ngx-remote-desktop is an Angular2+ module for connecting to a remote desktop using the guacamole protocol
Author: Emil Langazov
Latest version: 1.4.9

# ngx-remote-desktop
[![npm version](https://badge.fury.io/js/%40illgrenoble%2Fngx-remote-desktop.svg)](https://badge.fury.io/js/%40illgrenoble%2Fngx-remote-desktop)

For installation and usage details go [here](https://illgrenoble.github.io/ngx-remote-desktop/additional-documentation/installation.html)

`ngx-remote-desktop` is an Angular component for connecting to a remote desktop using the [guacamole remote desktop gateway](https://guacamole.apache.org/)

It has been built for use with Angular 5.0.0+. It has been tested in Chrome, Firefox, Edge and Safari. It makes heavy use of flex, therefore it will not work in browsers that do not support flex. 

There is no dependency on any presentation component library / framework (ng-bootstrap, clarity etc.). This component does not make any assertions about how the backend web socket broker to guacd is implemented.

By default, there are no toolbar items, however, you can add as many toolbar items as you wish and create a handler in your component. You can also override the scss if you wish to change the styling. The `RemoteDesktopManager` exposes some useful methods for generating a screenshot or thumbnail, entering and exiting full screen mode, focusing and unfocusing the display, getting the client state, subscribing to the remote desktop clipboard and sending data to the remote desktop clipboard.

![Screenshot](https://raw.githubusercontent.com/ILLGrenoble/ngx-remote-desktop/master/screenshot.png)

## Features
  - Fluid screen resizing and scaling
  - Full screen mode
  - Toolbar (auto hide when in full screen mode)
  - Take a screenshot
  - Get a thumbnail
  - Subscribe to the remote clipboard observable and receive remote clipboard data
  - Send data to the remote clipboard
  - Status bar (optional) to provide contextual information

For a full implementation example, see the [demo source code](https://github.com/ILLGrenoble/ngx-remote-desktop/tree/master/demo)

## Installation

To use `ngx-remote-desktop` in your project, install it via npm:

```
npm i @langazov/ngx-remote-desktop --save
```

We also require two peer dependencies:

```
npm i @langazov/guacamole-common-js --save
npm i screenfull --save
```

### Thank you
Thank you to the guacamole team for a fantastic project.
npm package: @langchain/azure-cosmosdb
Description: Azure CosmosDB integration for LangChain.js
Author: LangChain
Latest version: 1.2.0

# @langchain/azure-cosmosdb

This package contains the [Azure CosmosDB](https://learn.microsoft.com/azure/cosmos-db/) vector store integrations.

Learn more about how to use this package in the LangChain documentation:

- [Azure CosmosDB for NoSQL](https://js.langchain.com/docs/integrations/vector_stores/azure_cosmosdb_nosql)
- [Azure DocumentDB](https://js.langchain.com/docs/integrations/vector_stores/azure_documentdb)

## Installation

```bash npm2yarn
npm install @langchain/azure-cosmosdb @langchain/core
```

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of @langchain/core.
You can do so by adding appropriate fields to your project's `package.json` like this:

```json
{
  "name": "your-project",
  "version": "0.0.0",
  "dependencies": {
    "@langchain/core": "^0.3.0",
    "@langchain/azure-cosmosdb": "^0.2.5"
  },
  "resolutions": {
    "@langchain/core": "0.3.0"
  },
  "overrides": {
    "@langchain/core": "0.3.0"
  },
  "pnpm": {
    "overrides": {
      "@langchain/core": "0.3.0"
    }
  }
}
```

The field you need depends on the package manager you're using, but we recommend adding a field for the common `yarn`, `npm`, and `pnpm` to maximize compatibility.

## Usage

```typescript
import { AzureCosmosDBNoSQLVectorStore } from "@langchain/azure-cosmosdb";

const store = await AzureCosmosDBNoSQLVectorStore.fromDocuments(
  ["Hello, World!"],
  new OpenAIEmbeddings(),
  {
    databaseName: "langchain",
    containerName: "documents",
  }
);

const resultDocuments = await store.similaritySearch("hello");
console.log(resultDocuments[0].pageContent);
```
npm package: @langchain/azure-dynamic-sessions
Description: Sample integration for LangChain.js
Author: LangChain
Latest version: 1.0.1

# @langchain/azure-dynamic-sessions

This package contains the [Azure Container Apps dynamic sessions](https://learn.microsoft.com/azure/container-apps/sessions) tool integration.

Learn more about how to use this tool in the [LangChain documentation](https://js.langchain.com/docs/integrations/tools/azure_dynamic_sessions).

## Installation

```bash npm2yarn
npm install @langchain/azure-dynamic-sessions @langchain/core
```

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of @langchain/core.
You can do so by adding appropriate fields to your project's `package.json` like this:

```json
{
  "name": "your-project",
  "version": "0.0.0",
  "dependencies": {
    "@langchain/core": "^0.3.0"
  },
  "resolutions": {
    "@langchain/core": "^0.3.0"
  },
  "overrides": {
    "@langchain/core": "^0.3.0"
  },
  "pnpm": {
    "overrides": {
      "@langchain/core": "^0.3.0"
    }
  }
}
```

The field you need depends on the package manager you're using, but we recommend adding a field for the common `yarn`, `npm`, and `pnpm` to maximize compatibility.

## Tool usage

```typescript
import { SessionsPythonREPLTool } from "@langchain/azure-dynamic-sessions";

const tool = new SessionsPythonREPLTool({
  poolManagementEndpoint:
    process.env.AZURE_CONTAINER_APP_SESSION_POOL_MANAGEMENT_ENDPOINT || "",
});

const result = await tool.invoke("print('Hello, World!')\n1+2");

console.log(result);

// {
//   stdout: "Hello, World!\n",
//   stderr: "",
//   result: 3,
// }
```
npm package: @langchain/baidu-qianfan
Description: Baidu Qianfan integration for LangChain.js
Author: LangChain
Latest version: 1.0.3

# @langchain/baidu-qianfan

This package contains the LangChain.js integrations for Baidu Qianfan via the qianfan/sdk package.


## Installation

```bash npm2yarn
npm install @langchain/baidu-qianfan @langchain/core
```

## Chat models

This package adds support for Qianfan chat model inference.

Set the necessary environment variable (or pass it in via the constructor):

```bash
export QIANFAN_AK=""
export QIANFAN_SK=""
export QIANFAN_ACCESS_KEY=""
export QIANFAN_SECRET_KEY=""
```

```typescript
import { ChatBaiduQianfan } from "@langchain/baidu-qianfan";
import { HumanMessage } from "@langchain/core/messages";

const chat = new ChatBaiduQianfan({
    model: 'ERNIE-Lite-8K'
});
const message = new HumanMessage("北京天气");

const res = await chat.invoke([message]);
```

```typescript
import { BaiduQianfanEmbeddings } from "@langchain/baidu-qianfan";

const embeddings = new BaiduQianfanEmbeddings();
const res = await embeddings.embedQuery("Introduce the city Beijing");
```
npm package: @langchain/cerebras
Description: Cerebras integration for LangChain.js
Author: LangChain
Latest version: 1.0.4

# @langchain/cerebras

This package contains the LangChain.js integrations for Cerebras via the `@cerebras/cerebras_cloud_sdk` package.

## Installation

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

## Chat models

This package adds support for Cerebras chat model inference.

Set the necessary environment variable (or pass it in via the constructor):

```bash
export CEREBRAS_API_KEY=
```

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

const model = new ChatCerebras({
  apiKey: process.env.CEREBRAS_API_KEY, // Default value.
});

const message = new HumanMessage("What color is the sky?");

const res = await model.invoke([message]);
```

## Development

To develop the `@langchain/cerebras` package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/cerebras
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/cloudflare
Description: Cloudflare integration for LangChain.js
Author: LangChain
Latest version: 1.0.4

# @langchain/cloudflare

This package contains the LangChain.js integrations for Cloudflare through their SDK.

## Installation

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

## Development

To develop the Cloudflare package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/cloudflare
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/cohere
Description: Cohere integration for LangChain.js
Author: LangChain
Latest version: 1.0.4

# @langchain/cohere

This package contains the LangChain.js integrations for Cohere through their SDK.

## Installation

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

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of @langchain/core.
You can do so by adding appropriate field to your project's `package.json` like this:

```json
{
  "name": "your-project",
  "version": "0.0.0",
  "dependencies": {
    "@langchain/cohere": "^0.0.1",
    "@langchain/core": "^0.3.0"
  },
  "resolutions": {
    "@langchain/core": "0.3.0"
  },
  "overrides": {
    "@langchain/core": "0.3.0"
  },
  "pnpm": {
    "overrides": {
      "@langchain/core": "0.3.0"
    }
  }
}
```

The field you need depends on the package manager you're using, but we recommend adding a field for the common `yarn`, `npm`, and `pnpm` to maximize compatibility.

## Chat Models

This package contains the `ChatCohere` class, which is the recommended way to interface with the Cohere series of models.

To use, install the requirements, and configure your environment.

```bash
export COHERE_API_KEY=your-api-key
```

Then initialize

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

const model = new ChatCohere({
  apiKey: process.env.COHERE_API_KEY,
});
const response = await model.invoke([new HumanMessage("Hello world!")]);
```

### Streaming

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

const model = new ChatCohere({
  apiKey: process.env.COHERE_API_KEY,
});
const response = await model.stream([new HumanMessage("Hello world!")]);
```

## Embeddings

This package also adds support for `CohereEmbeddings` embeddings model.

```typescript
import { CohereEmbeddings } from "@langchain/cohere";

const embeddings = new CohereEmbeddings({
  apiKey: process.env.COHERE_API_KEY,
});
const res = await embeddings.embedQuery("Hello world");
```

## Development

To develop the `@langchain/cohere` package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/cohere
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/community
Description: Third-party integrations for LangChain.js
Author: LangChain
Latest version: 1.1.27

# 🦜️🧑‍🤝‍🧑 LangChain Community

[![CI](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml) ![npm](https://img.shields.io/npm/dm/@langchain/community) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchain.svg?style=social&label=Follow%20%40LangChain)](https://x.com/langchain)

## Quick Install

```bash
pnpm install @langchain/community
```

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of @langchain/core.
You can do so by adding appropriate field to your project's `package.json` like this:

```json
{
  "name": "your-project",
  "version": "0.0.0",
  "dependencies": {
    "@langchain/community": "^0.0.0",
    "@langchain/core": "^0.3.0"
  },
  "resolutions": {
    "@langchain/core": "^0.3.0"
  },
  "overrides": {
    "@langchain/core": "^0.3.0"
  },
  "pnpm": {
    "overrides": {
      "@langchain/core": "^0.3.0"
    }
  }
}
```

The field you need depends on the package manager you're using, but we recommend adding a field for the common `yarn`, `npm`, and `pnpm` to maximize compatibility.

## 🤔 What is this?

LangChain Community contains third-party integrations that implement the base interfaces defined in LangChain Core, making them ready-to-use in any LangChain application.

![LangChain Stack](../../docs/core_docs/static/svg/langchain_stack_062024.svg)

## 💁 Contributing

As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

For detailed information on how to contribute, see [here](../../CONTRIBUTING.md).
npm package: @langchain/deepseek
Description: Deepseek integration for LangChain.js
Author: LangChain
Latest version: 1.0.24

# @langchain/deepseek

This package contains the LangChain.js integrations for DeepSeek.

## Installation

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

## Chat models

This package adds support for DeepSeek's chat model inference.

Set the necessary environment variable (or pass it in via the constructor):

```bash
export DEEPSEEK_API_KEY=
```

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

const model = new ChatDeepSeek({
  apiKey: process.env.DEEPSEEK_API_KEY, // Default value.
  model: "<model_name>",
});

const res = await model.invoke([
  {
    role: "user",
    content: message,
  },
]);
```

## Development

To develop the `@langchain/deepseek` package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/deepseek
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/eslint
Description: Shared ESLint configuration for LangChain.js projects
Author: LangChain
Latest version: 0.1.0
Deprecated: This package is not intended for use

# @langchain/eslint

Shared ESLint configuration for LangChain.js projects.

## Installation

```bash
pnpm add -D @langchain/eslint
```

## Usage

Create an `eslint.config.ts` file in your project root:

```ts
import { langchainConfig } from "@langchain/eslint";

export default langchainConfig;
```

Or for specific presets:

```ts
import { base, node, browser } from "@langchain/eslint";

export default [...base, ...node];
```

## Available Configurations

- `langchainConfig` - Full LangChain configuration (includes all rules)
- `base` - Base TypeScript + Prettier configuration
- `node` - Node.js specific rules
- `browser` - Browser specific rules

## Customization

You can override any rules by adding your own configuration after importing:

```ts
import { langchainConfig, type Linter } from "@langchain/eslint";

const config: Linter.Config[] = [
  ...langchainConfig,
  {
    files: ["**/*.ts"],
    rules: {
      // Your custom rules
      "@typescript-eslint/no-explicit-any": "error",
    },
  },
];

export default config;
```
npm package: @langchain/exa
Description: Exa integration for LangChain.js
Author: LangChain
Latest version: 1.0.1

# @langchain/exa

This package contains the LangChain.js integrations for exa through their SDK.

## Installation

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

## Development

To develop the exa package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/exa
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/fireworks
Description: Fireworks integration for LangChain.js
Author: LangChain
Latest version: 0.1.2

# @langchain/fireworks

This package contains the LangChain.js integrations for Fireworks AI.

## Installation

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

This package depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you use it together with other LangChain packages, make sure they all resolve
to the same `@langchain/core` version.

## Chat models

Use `ChatFireworks` for chat-completions style models exposed by Fireworks'
OpenAI-compatible API.

```bash
export FIREWORKS_API_KEY="your-api-key"
```

```typescript
import { ChatFireworks } from "@langchain/fireworks";

const model = new ChatFireworks({
  model: "accounts/fireworks/models/firefunction-v2",
  temperature: 0,
});

const response = await model.invoke("Tell me a joke about rockets.");
console.log(response.content);
```

## LLMs

Use `Fireworks` for text-completion style models.

```typescript
import { Fireworks } from "@langchain/fireworks";

const model = new Fireworks({
  model: "accounts/fireworks/models/llama-v2-13b",
  temperature: 0,
});

const response = await model.invoke("1 + 1 =");
console.log(response);
```

## Embeddings

Use `FireworksEmbeddings` for embedding models exposed by Fireworks.

```typescript
import { FireworksEmbeddings } from "@langchain/fireworks";

const embeddings = new FireworksEmbeddings({
  model: "nomic-ai/nomic-embed-text-v1.5",
});

const vector = await embeddings.embedQuery("hello world");
console.log(vector);
```

## Development

Install dependencies from the monorepo root:

```bash
pnpm install
```

Build this package:

```bash
pnpm --filter @langchain/fireworks build
```

Run unit tests:

```bash
pnpm --filter @langchain/fireworks test
```

Run integration tests:

```bash
pnpm --filter @langchain/fireworks test:int
```

Run standard tests:

```bash
pnpm --filter @langchain/fireworks test:standard
```
npm package: @langchain/google
Description: Google integrations for LangChain.js
Author: LangChain
Latest version: 0.1.10

# @langchain/google

This package supports access to a variety of Google's models, including the Gemini
family of models and their Nano Banana image generation model. You can access these
models through either Google's [Google AI](https://ai.google.dev/) API (sometimes also
called the Generative AI API or the AI Studio API) or through the Google Cloud Platform
[Vertex AI](https://cloud.google.com/vertex-ai) service. It does not rely
on the "genai" library from Google, but rather uses direct REST calls.

This package will be replacing the [ChatGoogleGenerativeAI](google_generative_ai)
and [ChatVertex](google_vertex_ai) libraries.

## Installation

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

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that
all the packages depend on the same instance of @langchain/core.

## Chat Models

This package contains the `ChatGoogle` class, which is the recommended way
to interface with Google's models.

For detailed configuration and use, including how to get credentials, see the
[LangChain.js documentation](https://docs.langchain.com/oss/javascript/integrations/chat/google).

## Tools

`ChatGoogle` supports standard LangChain tool calling as
well as Gemini-specific "Specialty Tools" (like Code Execution and Grounding).

See the [LangChain.js documentation](https://docs.langchain.com/oss/javascript/integrations/chat/google).
for details.

## Reporting issues

Please report any problems encountered with the library in the
[LangChain.js github repository](https://github.com/langchain-ai/langchainjs/issues).

Please provide as many details as possible and make sure the title
references the @langchain/google library. A code sample that can reproduce
the issue is very welcome.

## Development

Contributions are welcome! You may wish to [open an issue](https://github.com/langchain-ai/langchainjs/issues)
before you begin and tag [@hntrl](https://github.com/hntrl) and
[@afirstenberg](https://github.com/afirstenberg) with your plans.

To develop the Google package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter=@langchain/google
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
pnpm test
pnpm test:int
```

Note that the integration tests run against currently supported models and
platforms.

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/groq
Description: Groq integration for LangChain.js
Author: LangChain
Latest version: 1.2.0

# @langchain/groq

This package contains the LangChain.js integrations for Groq via the groq/sdk package.

## Installation

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

## Chat models

This package adds support for Groq chat model inference.

Set the necessary environment variable (or pass it in via the constructor):

```bash
export GROQ_API_KEY=
```

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

const model = new ChatGroq({
  apiKey: process.env.GROQ_API_KEY, // Default value.
  model: "llama-3.3-70b-versatile",
});

const message = new HumanMessage("What color is the sky?");

const res = await model.invoke([message]);
```

## Development

To develop the `@langchain/groq` package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/groq
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/jigsawstack
Description: Sample integration for LangChain.js
Author: LangChain
Latest version: 0.1.0

# @langchain/jigsawstack

This package contains the LangChain.js integrations for JigsawStack through their SDK.

## Installation

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

## Development

To develop the jigsawstack package, you'll need to follow these instructions:

### Install dependencies

```bash
yarn install
```

### Build the package

```bash
yarn build
```

Or from the repo root:

```bash
yarn build --filter=@langchain/jigsawstack
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ yarn test
$ yarn test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
yarn lint && yarn format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `entrypoints` field in the `config` variable located inside `langchain.config.js` and run `yarn build` to generate the new entrypoint.
npm package: @langchain/langgraph-api
Description: In-memory implementation of the LangGraph.js API.
Latest version: 1.1.17

# LangGraph.js API

In-memory implementation of the LangGraph.js API.

## Tests

1. Build the latest code changes to test: `pnpm build`
1. Start a local server: `pnpm dev`
1. Run the tests: `pnpm test`
npm package: @langchain/langgraph-checkpoint-mongodb
Description: LangGraph
Author: LangChain
Latest version: 1.2.0

# @langchain/langgraph-checkpoint-mongodb

Implementation of a [LangGraph.js](https://github.com/langchain-ai/langgraphjs) CheckpointSaver that uses a MongoDB instance.

## Usage

```ts
import { MongoClient } from "mongodb";
import { MongoDBSaver } from "@langchain/langgraph-checkpoint-mongodb";

const writeConfig = {
  configurable: {
    thread_id: "1",
    checkpoint_ns: ""
  }
};
const readConfig = {
  configurable: {
    thread_id: "1"
  }
};


const client = new MongoClient(process.env.MONGODB_URL);

const checkpointer = new MongoDBSaver({ client });
const checkpoint = {
  v: 1,
  ts: "2024-07-31T20:14:19.804150+00:00",
  id: "1ef4f797-8335-6428-8001-8a1503f9b875",
  channel_values: {
    my_key: "meow",
    node: "node"
  },
  channel_versions: {
    __start__: 2,
    my_key: 3,
    "start:node": 3,
    node: 3
  },
  versions_seen: {
    __input__: {},
    __start__: {
      __start__: 1
    },
    node: {
      "start:node": 2
    }
  },
  pending_sends: [],
}

// store checkpoint
await checkpointer.put(writeConfig, checkpoint, {}, {});

// load checkpoint
await checkpointer.get(readConfig);

// list checkpoints
for await (const checkpoint of checkpointer.list(readConfig)) {
  console.log(checkpoint);
}

await client.close();
```
npm package: @langchain/langgraph-checkpoint-postgres
Description: LangGraph
Author: LangChain
Latest version: 1.0.1

# @langchain/langgraph-checkpoint-postgres

Implementation of a [LangGraph.js](https://github.com/langchain-ai/langgraphjs) CheckpointSaver that uses a Postgres DB.

## Usage

```ts
import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";

const writeConfig = {
  configurable: {
    thread_id: "1",
    checkpoint_ns: ""
  }
};
const readConfig = {
  configurable: {
    thread_id: "1"
  }
};

// you can optionally pass a configuration object as the second parameter
const checkpointer = PostgresSaver.fromConnString("postgresql://...", {
  schema: "schema_name" // defaults to "public"
});

// You must call .setup() the first time you use the checkpointer:
await checkpointer.setup();

const checkpoint = {
  v: 1,
  ts: "2024-07-31T20:14:19.804150+00:00",
  id: "1ef4f797-8335-6428-8001-8a1503f9b875",
  channel_values: {
    my_key: "meow",
    node: "node"
  },
  channel_versions: {
    __start__: 2,
    my_key: 3,
    "start:node": 3,
    node: 3
  },
  versions_seen: {
    __input__: {},
    __start__: {
      __start__: 1
    },
    node: {
      "start:node": 2
    }
  },
  pending_sends: [],
}

// store checkpoint
await checkpointer.put(writeConfig, checkpoint, {}, {});

// load checkpoint
await checkpointer.get(readConfig);

// list checkpoints
for await (const checkpoint of checkpointer.list(readConfig)) {
  console.log(checkpoint);
}
```

## Usage with existing connection pool

```ts
import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
import pg from "pg";

// You can use any existing postgres connection pool
// we create a new pool here for the sake of the example
const pool = new pg.Pool({
  connectionString: "postgresql://..."
});

const checkpointer = new PostgresSaver(pool, undefined, {
  schema: "schema_name"
});

await checkpointer.setup();

// ...
```

## Testing

Spin up testing PostgreSQL

```bash
docker-compose up -d && docker-compose logs -f
```

Then use the following connection string to initialize your checkpointer:

```ts
const testCheckpointer = PostgresSaver.fromConnString(
  "postgresql://user:password@localhost:5434/testdb"
);
```
npm package: @langchain/langgraph-checkpoint-sqlite
Description: LangGraph
Author: LangChain
Latest version: 1.0.1

# @langchain/langgraph-checkpoint-sqlite

Implementation of a [LangGraph.js](https://github.com/langchain-ai/langgraphjs) CheckpointSaver that uses a SQLite DB.

## Usage

```ts
import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";

const writeConfig = {
  configurable: {
    thread_id: "1",
    checkpoint_ns: ""
  }
};
const readConfig = {
  configurable: {
    thread_id: "1"
  }
};

const checkpointer = SqliteSaver.fromConnString(":memory:");
const checkpoint = {
  v: 1,
  ts: "2024-07-31T20:14:19.804150+00:00",
  id: "1ef4f797-8335-6428-8001-8a1503f9b875",
  channel_values: {
    my_key: "meow",
    node: "node"
  },
  channel_versions: {
    __start__: 2,
    my_key: 3,
    "start:node": 3,
    node: 3
  },
  versions_seen: {
    __input__: {},
    __start__: {
      __start__: 1
    },
    node: {
      "start:node": 2
    }
  },
  pending_sends: [],
}

// store checkpoint
await checkpointer.put(writeConfig, checkpoint, {}, {})

// load checkpoint
await checkpointer.get(readConfig)

// list checkpoints
for await (const checkpoint of checkpointer.list(readConfig)) {
  console.log(checkpoint);
}
```
npm package: @langchain/langgraph-cli
Description: The official command-line interface for LangGraph.js, providing tools to create, develop, and deploy LangGraph.js applications.
Latest version: 1.1.17

# LangGraph.js CLI

The official command-line interface for LangGraph.js, providing tools to create, develop, and deploy LangGraph.js applications.

## Installation

The `@langchain/langgraph-cli` is a CLI binary that can be run via `npx` or installed via your package manager of choice:

```bash
npx @langchain/langgraph-cli
```

## Commands

### `langgraphjs dev`

Run LangGraph.js API server in development mode with hot reloading.

```bash
npx @langchain/langgraph-cli dev
```

### `langgraphjs build`

Build a Docker image for your LangGraph.js application.

```bash
npx @langchain/langgraph-cli build
```

### `langgraphjs up`

Run LangGraph.js API server in Docker.

```bash
npx @langchain/langgraph-cli up
```

### `langgraphjs dockerfile`

Generate a Dockerfile for custom deployments

```bash
npx @langchain/langgraph-cli dockerfile <save path>
```

## Configuration

The CLI uses a `langgraph.json` configuration file with these key settings:

```json5
{
  // Required: Graph definitions
  graphs: {
    graph: "./src/graph.ts:graph",
  },

  // Optional: Node version (20 only at the moment)
  node_version: "20",

  // Optional: Environment variables
  env: ".env",

  // Optional: Additional Dockerfile commands
  dockerfile_lines: [],
}
```

See the [full documentation](https://langchain-ai.github.io/langgraph/cloud/reference/cli) for detailed configuration options.
npm package: @langchain/langgraph-sdk
Description: Client library for interacting with the LangGraph API
Latest version: 1.8.8

# LangGraph JS/TS SDK

This repository contains the JS/TS SDK for interacting with the LangGraph REST API.

## Quick Start

To get started with the JS/TS SDK, [install the package](https://www.npmjs.com/package/@langchain/langgraph-sdk)

```bash
pnpm add @langchain/langgraph-sdk
```

You will need a running LangGraph API server. If you're running a server locally using `langgraph-cli`, SDK will automatically point at `http://localhost:8123`, otherwise
you would need to specify the server URL when creating a client.

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

const client = new Client();

// List all assistants
const assistants = await client.assistants.search({
  metadata: null,
  offset: 0,
  limit: 10,
});

// We auto-create an assistant for each graph you register in config.
const agent = assistants[0];

// Start a new thread
const thread = await client.threads.create();

// Start a streaming run
const messages = [{ role: "human", content: "what's the weather in la" }];

const streamResponse = client.runs.stream(
  thread["thread_id"],
  agent["assistant_id"],
  {
    input: { messages },
  }
);

for await (const chunk of streamResponse) {
  console.log(chunk);
}
```

## Documentation

To generate documentation, run the following commands:

1. Generate docs.

        pnpm typedoc

1. Consolidate doc files into one markdown file.

        npx concat-md --decrease-title-levels --ignore=js_ts_sdk_ref.md --start-title-level-at 2 docs > docs/js_ts_sdk_ref.md

1. Copy `js_ts_sdk_ref.md` to MkDocs directory.

        cp docs/js_ts_sdk_ref.md ../../docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md

## Reference Documentation

The reference documentation is available [here](https://reference.langchain.com/javascript/modules/_langchain_langgraph-sdk.html).

More usage examples can be found [here](https://docs.langchain.com/langsmith/sdk#js).


## Change Log

The change log for new versions can be found [here](https://github.com/langchain-ai/langgraphjs/blob/main/libs/sdk/CHANGELOG.md).
npm package: @langchain/mistralai
Description: MistralAI integration for LangChain.js
Author: LangChain
Latest version: 1.0.7

# @langchain/mistralai

This package contains the LangChain.js integrations for Mistral through their SDK.

## Installation

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

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of @langchain/core.
You can do so by adding appropriate field to your project's `package.json` like this:

```json
{
  "name": "your-project",
  "version": "0.0.0",
  "dependencies": {
    "@langchain/core": "^0.3.0",
    "@langchain/mistralai": "^0.0.0"
  },
  "resolutions": {
    "@langchain/core": "^0.3.0"
  },
  "overrides": {
    "@langchain/core": "^0.3.0"
  },
  "pnpm": {
    "overrides": {
      "@langchain/core": "^0.3.0"
    }
  }
}
```

The field you need depends on the package manager you're using, but we recommend adding a field for the common `yarn`, `npm`, and `pnpm` to maximize compatibility.

## Chat Models

This package contains the `ChatMistralAI` class, which is the recommended way to interface with the Mistral series of models.

To use, install the requirements, and configure your environment.

```bash
export MISTRAL_API_KEY=your-api-key
```

Then initialize

```typescript
import { ChatMistralAI } from "@langchain/mistralai";

const model = new ChatMistralAI({
  apiKey: process.env.MISTRAL_API_KEY,
  modelName: "mistral-small",
});
const response = await model.invoke(new HumanMessage("Hello world!"));
```

### Streaming

```typescript
import { ChatMistralAI } from "@langchain/mistralai";

const model = new ChatMistralAI({
  apiKey: process.env.MISTRAL_API_KEY,
  modelName: "mistral-small",
});
const response = await model.stream(new HumanMessage("Hello world!"));
```

## Embeddings

This package also adds support for Mistral's embeddings model.

```typescript
import { MistralAIEmbeddings } from "@langchain/mistralai";

const embeddings = new MistralAIEmbeddings({
  apiKey: process.env.MISTRAL_API_KEY,
});
const res = await embeddings.embedQuery("Hello world");
```

## Development

To develop the Mistral package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/mistralai
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/mixedbread-ai
Description: Mixedbread AI integration for LangChain.js
Author: LangChain
Latest version: 1.0.1

# @langchain/mixedbread-ai

This package contains the LangChain.js integrations for the [Mixedbread AI API](https://mixedbread.ai/).

## Installation

```bash
npm install @langchain/mixedbread-ai
```

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/). If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of `@langchain/core`.

## Authentication

To use this package, you need a Mixedbread AI API key. You can obtain your API key by signing up at [Mixedbread AI](https://mixedbread.ai).

Either set the `MXBAI_API_KEY` environment variable to your Mixedbread AI API key, or pass it as the `apiKey` option to the constructor of the class you are using.

## Embeddings

This package provides access to the different embedding models provided by the Mixedbread AI API, such as the "mixedbread-ai/mxbai-embed-large-v1" model.

Learn more: [Embeddings API](https://mixedbread.ai/docs/embeddings)

```typescript
const embeddings = new MixedbreadAIEmbeddings({ apiKey: "your-api-key" });
const texts = ["Baking bread is fun", "I love baking"];
const result = await embeddings.embedDocuments(texts);
console.log(result);
```

## Reranking

This package provides access to the reranking API provided by Mixedbread AI. It allows you to rerank a list of documents based on a query. Available models include "mixedbread-ai/mxbai-rerank-large-v1".

Learn more: [Reranking API](https://mixedbread.ai/docs/reranking)

```typescript
const reranker = new MixedbreadAIReranker({ apiKey: "your-api-key" });
const documents = [
  { pageContent: "To bake bread you need flour" },
  { pageContent: "To bake bread you need yeast" },
];
const query = "What do you need to bake bread?";
const result = await reranker.compressDocuments(documents, query);
console.log(result);
```

## Development

To develop the `@langchain/mixedbread-ai` package, follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/mixedbread-ai
```

### Run tests

Test files should live within a `tests/` folder in the `src/` directory. Unit tests should end in `.test.ts` and integration tests should end in `.int.test.ts`:

```bash
pnpm test
pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entry points

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entry point.
npm package: @langchain/mongodb
Description: Sample integration for LangChain.js
Author: LangChain
Latest version: 1.1.0

# @langchain/mongodb

This package contains the LangChain.js integrations for MongoDB through their SDK.

## Installation

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

This package, along with the main LangChain package, depends on [`@langchain/core`](https://npmjs.com/package/@langchain/core/).
If you are using this package with other LangChain packages, you should make sure that all of the packages depend on the same instance of @langchain/core.
You can do so by adding appropriate field to your project's `package.json` like this:

```json
{
  "name": "your-project",
  "version": "0.0.0",
  "dependencies": {
    "@langchain/core": "^0.3.0",
    "@langchain/mongodb": "^0.0.0"
  },
  "resolutions": {
    "@langchain/core": "^0.3.0"
  },
  "overrides": {
    "@langchain/core": "^0.3.0"
  },
  "pnpm": {
    "overrides": {
      "@langchain/core": "^0.3.0"
    }
  }
}
```

The field you need depends on the package manager you're using, but we recommend adding a field for the common `yarn`, `npm`, and `pnpm` to maximize compatibility.

## Development

To develop the MongoDB package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/mongodb
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

The tests in this package require an instance of MongoDB Atlas running, either running locally or as a remote Atlas cluster. A URI pointing to
an existing Atlas cluster can be provided to the tests by specifying the `MONGODB_ATLAS_URI` environment variable:

```bash
MONGODB_ATLAS_URI='<atlas URI>' pnpm test:int
```

If running against a remote Atlas cluster, the user must have readWrite permissions on the `langchain_test` database.

If no `MONGODB_ATLAS_URI` is provided, the test suite will attempt to launch an instance of local Atlas in a container using [testcontainers](https://testcontainers.com/). This requires a container engine, see the [testcontainer backing engine documentation](https://node.testcontainers.org/supported-container-runtimes/) for details.

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/nomic
Description: Nomic integration for LangChain.js
Author: LangChain
Latest version: 1.0.1

# @langchain/nomic

This package contains the LangChain.js integrations for Nomic via the @nomic-ai/atlas package.

## Installation

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

## Embeddings

This package adds support for Nomic embeddings.

Currently, they offer two embeddings models:

- `nomic-embed-text-v1`
- `nomic-embed-text-v1.5`

`nomic-embed-text-v1.5` allows for you to customize the number of dimensions returned. It defaults to the largest possible number of dimensions (768), or you can select 64, 128, 256, or 512.

Now set the necessary environment variable (or pass it in via the constructor):

```bash
export NOMIC_API_KEY=
```

```typescript
import { NomicEmbeddings } from "@langchain/nomic";

const nomicEmbeddings = new NomicEmbeddings({
  apiKey: process.env.NOMIC_API_KEY, // Default value.
  modelName: "nomic-embed-text-v1", // Default value.
});

const docs = [
  "hello world",
  "nomic embeddings!",
  "super special langchain integration package",
  "what color is the sky?",
];

const embeddings = await nomicEmbeddings.embedDocuments(docs);
```

## Development

To develop the `@langchain/nomic` package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/nomic
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.
npm package: @langchain/ollama
Description: Ollama integration for LangChain.js
Author: LangChain
Latest version: 1.2.6

# @langchain/ollama

This package contains the LangChain.js integrations for Ollama via the `ollama` TypeScript SDK.

## Installation

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

TODO: add setup instructions for Ollama locally

## Chat Models

```typescript
import { ChatOllama } from "@langchain/ollama";

const model = new ChatOllama({
  model: "llama3", // Default value.
});

const result = await model.invoke(["human", "Hello, how are you?"]);
```

## Development

To develop the `@langchain/ollama` package, you'll need to follow these instructions:

### Install dependencies

```bash
pnpm install
```

### Build the package

```bash
pnpm build
```

Or from the repo root:

```bash
pnpm build --filter @langchain/ollama
```

### Run tests

Test files should live within a `tests/` file in the `src/` folder. Unit tests should end in `.test.ts` and integration tests should
end in `.int.test.ts`:

```bash
$ pnpm test
$ pnpm test:int
```

### Lint & Format

Run the linter & formatter to ensure your code is up to standard:

```bash
pnpm lint && pnpm format
```

### Adding new entrypoints

If you add a new file to be exported, either import & re-export from `src/index.ts`, or add it to the `exports` field in the `package.json` file and run `pnpm build` to generate the new entrypoint.