Elixir LangChain

https://hexdocs.pm/langchain
Admin
Elixir LangChain is a library for developing applications powered by large language models (LLMs)...
Tokens:238,371
Snippets:2,432
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Initialize and Run LLMChain with ChatGoogleAI and Google Search

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatGoogleAI.md

Example of initializing an LLMChain with ChatGoogleAI, adding a user message, and integrating the Google Search tool. This setup allows the model to search the web for current information to ground its responses. The `LLMChain.run()` function executes the chain.

```elixir
alias LangChain.Chains.LLMChain
alias LangChain.Message
alias LangChain.NativeTool

model = ChatGoogleAI.new!(%{temperature: 0, stream: false, model: "gemini-2.0-flash"})

{:ok, updated_chain} =
   %{llm: model, verbose: false, stream: false}
   |> LLMChain.new!()
   |> LLMChain.add_message(
     Message.new_user!("What is the current Google stock price?")
   )
   |> LLMChain.add_tools(NativeTool.new!(%{name: "google_search", configuration: %{}}))
   |> LLMChain.run()
```

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

### Copy and Edit .env Example

Source: https://hexdocs.pm/langchain

Before running live API tests, copy the example environment file and populate it with your private API keys.

```bash
cp .env.example .env
# Edit .env with your private API keys
```

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

### Generate Consistent Titles with Examples

Source: https://hexdocs.pm/langchain/LangChain.Chains.TextToTitleChain.md

This example shows how to provide example titles to the LLM to achieve more consistent formatting and style in the generated titles. It includes the LLM, user text, and a list of example titles.

```elixir
llm = ChatOpenAI.new!(%{model: "gpt-3.5-turbo", stream: false, seed: 0})
user_text = "Let's start a new blog post about the magical properties of
pineapple cookies."

%{ 
  llm: llm,
  input_text: user_text,
  examples: [
    "Blog Post: Making Delicious and Healthy Smoothies",
    "System Email: Notifying Users of Planned Downtime"
  ]
}
|> TextToTitleChain.new!()
|> TextToTitleChain.evaluate()

#=> "Blog Post: Exploring the Magic of Pineapple Cookies"
```

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

### LangchainPrompt - Minimal Example

Source: https://hexdocs.pm/langchain_prompt/LangchainPrompt.html

A minimal example demonstrating how to define and use a LangchainPrompt module for summarization.

```APIDOC
## LangchainPrompt - Minimal Example

This example shows how to create a prompt module that summarizes text using an LLM adapter.

### Description
Implements the `LangchainPrompt.Prompt` behavior to define a summarization task.

### Usage
```elixir
defmodule MyApp.Prompts.Summarise do
  @behaviour LangchainPrompt.Prompt

  alias LangchainPrompt.Profile
  alias LangchainPrompt.Adapters.Langchain

  @impl true
  def set_profile(_assigns) do
    %Profile{
      adapter: Langchain,
      opts: %{
        chat_module: LangChain.ChatModels.ChatOpenAI,
        model: "gpt-4o-mini"
      }
    }
  end

  @impl true
  def generate_system_prompt(_assigns), do: "You are a concise summariser."

  @impl true
  def generate_user_prompt(%{text: text}), do: "Summarise: #{text}"

  @impl true
  def post_process(_assigns, %LangchainPrompt.Message{content: content}),
    do: {:ok, content}
end

{:ok, summary} = LangchainPrompt.execute(MyApp.Prompts.Summarise, %{text: "..."})
```
```

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

### Full Chat Example with Bumblebee and Llama 2

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatBumblebee.md

A complete example demonstrating a streaming conversation with Llama 2 through Bumblebee, including message handling and LLMChain setup.

```elixir
defmodule MyApp.BumblebeeChat do
  @doc false
  alias LangChain.Message
  alias LangChain.ChatModels.ChatBumblebee
  alias LangChain.Chains.LLMChain

  def run_chat do
    # Used when streaming responses. The function fires as data is received.
    callback_fn = fn
      %LangChain.MessageDelta{} = delta ->
        # write to the console as the response is streamed back
        IO.write(delta.content)

      %LangChain.Message{} = message ->
        # inspect the fully finished message that was assembled from all the deltas
        IO.inspect(message, label: "FULLY ASSEMBLED MESSAGE")
    end

    # create and run the chain
    {:ok, _updated_chain, %Message{} = message} =
      LLMChain.new!(%{ 
        llm:
          ChatBumblebee.new!(%{ 
            serving: Llama2ChatModel,
            template_format: :llama_2,
            stream: true
          }),
        verbose: true
      })
      |> LLMChain.add_message(Message.new_system!("You are a helpful assistant."))
      |> LLMChain.add_message(Message.new_user!("What is the capital of Taiwan? And share up to 5 interesting facts about the city."))
      |> LLMChain.run(callback_fn: callback_fn)

    # print the LLM's fully assembled answer
    IO.puts("\n\n")
    IO.puts(message.content)
    IO.puts("\n\n")
  end
end
```

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

### Start LangChain MCP Test Server from Command Line

Source: https://hexdocs.pm/langchain_mcp/LangChainMCP.TestServer.html

Run this command in your terminal to start the LangChain MCP test server. This is a convenient way to launch the server for testing.

```bash
mix test_server
```

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

### Install LangChain and Kino Dependencies

Source: https://hexdocs.pm/langchain/getting_started.md

Install the necessary LangChain and Kino dependencies using Mix.install. This is the first step before using the library.

```elixir
Mix.install([
  {:langchain, "~> 0.4.0-rc.1"},
  {:kino, "~> 0.12.0"}
])
```

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

### Message Creation Examples

Source: https://hexdocs.pm/langchain/LangChain.Message.md

Examples of how to create different types of messages.

```APIDOC
## Examples

A basic system message example:

```elixir
alias LangChain.Message

Message.new_system!("You are a helpful assistant.")
```

A basic user message:

```elixir
Message.new_user!("Who is Prime Minister of the moon?")
```

A multi-part user message:

```elixir
alias LangChain.Message.ContentPart

Message.new_user!([
  ContentPart.text!("What is in this picture?"),
  ContentPart.image_url!("https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg")
])
```
```

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

### Minimal Example of a Prompt Module

Source: https://hexdocs.pm/langchain_prompt/index.html

Demonstrates how to define a basic prompt module implementing the `LangchainPrompt.Prompt` behaviour.

```APIDOC
## Module: MyApp.Prompts.Summarise

### Description
Implements a prompt module for summarization tasks.

### Behaviour
@behaviour LangchainPrompt.Prompt

### Functions
- `set_profile/1`: Configures the LLM adapter and model.
- `generate_system_prompt/1`: Defines the system message.
- `generate_user_prompt/1`: Generates the user prompt based on input.
- `post_process/2`: Processes the LLM's response.

### Example Usage
```elixir
defmodule MyApp.Prompts.Summarise do
  @behaviour LangchainPrompt.Prompt

  alias LangchainPrompt.Profile
  alias LangchainPrompt.Adapters.Langchain

  @impl true
  def set_profile(_assigns) do
    %Profile{
      adapter: Langchain,
      opts: %{
        chat_module: LangChain.ChatModels.ChatOpenAI,
        model: "gpt-4o-mini"
      }
    }
  end

  @impl true
  def generate_system_prompt(_assigns), do: "You are a concise summariser."

  @impl true
  def generate_user_prompt(%{text: text}), do: "Summarise: #{text}"

  @impl true
  def post_process(_assigns, %LangchainPrompt.Message{content: content}),
    do: {:ok, content}
end

{:ok, summary} = LangchainPrompt.execute(MyApp.Prompts.Summarise, %{text: "..."})
```
```

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

### Start Scraper Process

Source: https://hexdocs.pm/langchainex/LangChain.Scraper.html

Starts the Scraper GenServer process. Accepts optional arguments for configuration.

```elixir
start_link(opts \\ [])
```

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

### Example Live Integration Test

Source: https://hexdocs.pm/langchain_mcp/index.html

An example of a live integration test that connects to the MCP server and checks for available functions.

```elixir
@tag :live_call
test "integrates with real MCP server" do
  adapter = Adapter.new(client: MyApp.MCPClient)
  functions = Adapter.to_functions(adapter)

  assert length(functions) > 0
end
```

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

### Example Usage with LLMChain

Source: https://hexdocs.pm/langchain/LangChain.Tools.Calculator.md

Provides a practical example of using the Calculator tool within an LLMChain to answer a math question.

```APIDOC
## Example Usage with LLMChain

### Description
This example demonstrates how to integrate the Calculator tool into an `LLMChain` to answer a user's math question. The chain is configured to run until a successful result is obtained.

### Code Example

```elixir
{:ok, updated_chain, %Message{} = message} =
  %{llm: ChatOpenAI.new!(%{temperature: 0}), verbose: true}
  |> LLMChain.new!()
  |> LLMChain.add_message(
    Message.new_user!("Answer the following math question: What is 100 + 300 - 200?")
  )
  |> LLMChain.add_functions(Calculator.new!())
  |> LLMChain.run(mode: :until_success)
```

### Verbose Log Output Breakdown

1.  **LLM Configuration**: Shows the details of the `ChatOpenAI` model being used.
2.  **Messages**: Displays the user's message containing the math question.
3.  **Tools**: Lists the available tools, including the `calculator` tool with its schema and description.
4.  **Single Message Response**: The LLM's initial response, which includes a `tool_call` to the `calculator` function with the expression `"100 + 300 - 200"`.
5.  **Executing Function**: Indicates that the `calculator` function is being executed.
6.  **Function Result**: The result of the calculator function, which is `"200"`.
7.  **Tool Results**: The `tool_result` message confirming the successful execution of the `calculator` tool with the result `"200"`.
8.  **Final Response**: The LLM's final answer to the user, incorporating the result from the calculator: `"The result of the math question "100 + 300 - 200" is 200."`
```

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

### Start and Scrape with Default Scraper

Source: https://hexdocs.pm/langchainex/LangChain.Scraper.html

Initiates the Scraper and performs a basic scrape operation. Ensure the Scraper is started before calling scrape.

```elixir
Scraper.start_link()
input_text = "John Doe is 30 years old."
{:ok, result} = Scraper.scrape(scraper_pid, input_text)
```

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

### Example Usage of ChatDeepSeek

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatDeepSeek.md

Demonstrates basic usage of the ChatDeepSeek module, including initialization and integration with LLMChain.

```APIDOC
## Example Usage

```elixir
# Basic usage
model = ChatDeepSeek.new!(%{ 
  model: "deepseek-chat", 
  api_key: "your-api-key-here"
})

# Using with LLMChain
{:ok, chain} = 
  LLMChain.new!(%{llm: model})
  |> LLMChain.add_message(Message.new_user!("Hello!"))

{:ok, response} = LLMChain.run(chain)
```
```

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

### Install LangChain and Kino Libraries

Source: https://hexdocs.pm/langchain/context-specific-image-descriptions.md

Install the necessary Elixir libraries for LangChain and Kino. Ensure you are using compatible versions.

```elixir
Mix.install([
  {:langchain, "~> 0.3.0"},
  {:kino, "~> 0.12.0"}
])
```

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

### Register Client Asynchronously in Application Start

Source: https://hexdocs.pm/langchain_mcp/LangChain.MCP.StatusMonitor.html

Register a client asynchronously after the application supervisor has started. This is useful for background registration without blocking the startup process.

```elixir
defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      {MyApp.GitHubMCP, transport: {:streamable_http, base_url: "http://localhost:5000"}}
    ]

    {:ok, _pid} = Supervisor.start_link(children, strategy: :one_for_one)

    # Register after starting
    Task.start(fn ->
      StatusMonitor.register_client_by_name(MyApp.GitHubMCP, :github)
    end)

    {:ok, self()}
  end
end
```

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

### Example Usage of LangchainPrompt.Prompt

Source: https://hexdocs.pm/langchain_prompt/LangchainPrompt.Prompt.html

An example Elixir module demonstrating how to implement the LangchainPrompt.Prompt behaviour for a sentiment classification task.

```APIDOC
## Example

```elixir
defmodule MyApp.Prompts.Classify do
  @behaviour LangchainPrompt.Prompt

  @impl true
  def set_profile(_assigns), do: MyApp.AIProfiles.get(:fast)

  @impl true
  def generate_system_prompt(_assigns) do
    "Classify the sentiment as :positive, :neutral, or :negative. " <> 
    "Reply with exactly one word."
  end

  @impl true
  def generate_user_prompt(%{text: text}), do: text

  @impl true
  def post_process(_assigns, %LangchainPrompt.Message{content: content}) do
    case String.trim(content) do
      "positive" -> {:ok, :positive}
      "neutral"  -> {:ok, :neutral}
      "negative" -> {:ok, :negative}
      other      -> {:error, {:unexpected_response, other}}
    end
  end
end
```
```

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

### Setup ChatAnthropic Client

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatAnthropic.md

Sets up a ChatAnthropic client configuration.

```APIDOC
## `new` and `new!`

### Description
Sets up a ChatAnthropic client configuration. `new` returns `{:ok, t()}` or `{:error, Ecto.Changeset.t()}`, while `new!` returns `t()` or raises an error if invalid.

### Method
`new/1`, `new!/1`

### Endpoint
N/A

### Parameters
#### Request Body
- **attrs** (map) - Required - Attributes for configuring the ChatAnthropic client.

### Request Example
```elixir
# Using new/1
ChatAnthropic.new(%{model: "claude-3-opus-20240229", api_key: "YOUR_API_KEY"})

# Using new!/1
ChatAnthropic.new!(%{model: "claude-3-opus-20240229", api_key: "YOUR_API_KEY"})
```

### Response
#### Success Response (`new`)
- **{:ok, ChatAnthropic.t()}** - Successfully created client configuration.

#### Success Response (`new!`)
- **ChatAnthropic.t()** - Successfully created client configuration.

#### Error Response (`new`)
- **{:error, Ecto.Changeset.t()}** - Error during client configuration.

#### Error Response (`new!`) - Raises an exception.

### Options for `attrs`
- **`:model`** (string) - The Anthropic model to use (e.g., `"claude-3-opus-20240229"`).
- **`:api_key`** (string) - Your Anthropic API key.
- **`:temperature`** (float) - Controls randomness. Lower values make output more deterministic.
- **`:max_tokens`** (integer) - The maximum number of tokens to generate.
- **`:system`** (string) - System prompt to guide the model's behavior.
- **`:beta_headers`** (list of strings) - Beta headers for specific features, e.g., `["structured-outputs-2025-11-13", "files-api-2025-04-14"]`.
```

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

### Install LangChain Elixir Library

Source: https://hexdocs.pm/langchain/custom_functions.md

Install the LangChain Elixir library using Mix. This is the first step to using LangChain in your Elixir project.

```elixir
Mix.install([
  {:langchain, "~> 0.3.0"}
])
```

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

### FileOpenAI Uploader Setup and Usage

Source: https://hexdocs.pm/langchain/LangChain.FileUploader.FileOpenAI.md

This snippet demonstrates how to initialize the FileOpenAI uploader and use it to upload a file to OpenAI.

```APIDOC
## LangChain.FileUploader.FileOpenAI

### Description
Uploads files to OpenAI's [Files API](https://platform.openai.com/docs/api-reference/files).

### Method
POST (Implicitly via `LangChain.FileUploader.upload`)

### Endpoint
(OpenAI Files API endpoint, managed by the library)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **file_bytes** (binary) - Required - The content of the file to upload.
- **file_meta** (map) - Optional - Metadata for the file, including:
  - **filename** (string) - Required - The name of the file.
  - **mime_type** (string) - Required - The MIME type of the file.
  - **purpose** (string) - Optional - The purpose of the file (defaults to "user_data").

### Request Example
```elixir
{:ok, uploader} = LangChain.FileUploader.FileOpenAI.new(%{api_key: "sk-..."})

{:ok, result} = LangChain.FileUploader.upload(uploader, file_bytes, %{
  filename: "document.pdf",
  mime_type: "application/pdf"
})

result.file_id
#=> "file-abc123"
```

### Response
#### Success Response (200)
- **file_id** (string) - The ID of the uploaded file.

#### Response Example
```json
{
  "file_id": "file-abc123"
}
```
```

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

### Start WebSocket Connection

Source: https://hexdocs.pm/langchain/LangChain.WebSocket.md

Starts a WebSocket connection and links it to the calling process. The connection is established immediately. Ensure the URL is provided and consider adding custom headers.

```elixir
 {:ok, ws} = LangChain.WebSocket.start_link(
 url: "wss://api.openai.com/v1/responses",
 headers: [{"authorization", "Bearer sk-..."}]
 )
```

```elixir
 @spec start_link(keyword()) :: GenServer.on_start()
```

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

### List Available Tools

Source: https://hexdocs.pm/langchain_mcp/LangChain.MCP.ToolExecutor.html

Lists all available tools on an MCP server and verifies that the returned value is a list. This example uses the `list_tools/1` function.

```elixir
iex> {:ok, tools} = ToolExecutor.list_tools(MyApp.MCPClient)
iex> is_list(tools)
true
```

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

### Start MCP Client in Supervision Tree

Source: https://hexdocs.pm/langchain_mcp/index.html

Start your defined MCP client within your application's supervision tree. Configure the transport layer, such as `{:streamable_http, base_url: ...}`.

```elixir
defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      {MyApp.GitHubMCP,
       transport: {:streamable_http, base_url: "http://localhost:5000"}}
    ]

    Supervisor.start_link(children, strategy: :one_for_one)
  end
end
```

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

### Start Docker-based MCP Servers

Source: https://hexdocs.pm/langchain_mcp/readme.html

Initiate MCP servers using Docker Compose for testing against external or Dockerized MCP services.

```bash
docker-compose up -d

```

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

### Example handler for `llm_response_headers`

Source: https://hexdocs.pm/langchain/LangChain.Chains.ChainCallbacks.md

An example function demonstrating how to handle LLM response headers, potentially sending them to a LiveView. This assumes the LiveView's PID was stored in the chain's custom_context.

```elixir
def handle_llm_response_headers(chain, response_headers) do
  # This demonstrates how to send the response headers to a
  # LiveView assuming the LiveView's pid was stored in the chain's
  # custom_context.
  send(chain.custom_context.live_view_pid, {:req_response_headers, response_headers})

  IO.inspect(response_headers)
end
```

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

### Define and Start MCP Client

Source: https://hexdocs.pm/langchain_mcp/LangChain.MCP.Client.html

Define a custom MCP client module using LangChain.MCP.Client and start its process. Ensure the transport configuration matches your MCP service.

```elixir
defmodule MyApp.GitHubMCP do
  use LangChain.MCP.Client,
    name: "GitHub MCP",
    version: "1.0.0",
    protocol_version: "2025-03-26"
end

# Start the client
{:ok, pid} = MyApp.GitHubMCP.start_link(
  transport: {:streamable_http, base_url: "http://localhost:5000"}
)
```

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

### Start LangChain MCP Test Server Programmatically

Source: https://hexdocs.pm/langchain_mcp/LangChainMCP.TestServer.html

Use this function to start the test server within your Elixir supervision tree. Specify the transport and port for the streamable HTTP server.

```elixir
Anubis.Server.Supervisor.start_link(
  LangChainMCP.TestServer,
  transport: :streamable_http,
  streamable_http: [port: 5000]
)
```

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

### Create New LLMChain (Raise on Error)

Source: https://hexdocs.pm/langchain/LangChain.Chains.LLMChain.md

Starts a new LLMChain configuration and returns it directly. Raises an error if the configuration is invalid.

```elixir
@spec new!(attrs :: map()) :: t() | no_return()
```

```elixir
    chain = LLMChain.new!(%{ 
      llm: %ChatOpenAI{model: "gpt-3.5-turbo", stream: true},
      messages: [%Message.new_system!("You are a helpful assistant.")]
    })
```

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

### Set up Local API Keys with .env.example

Source: https://hexdocs.pm/langchain/changelog.md

This command copies the .env.example template file to .env, which should then be populated with your specific API keys. This is the recommended starting point for local development.

```bash
cp .env.example .env
# Populate .env with your API keys
```

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

### Emit Retriever Get Relevant Documents Start Event

Source: https://hexdocs.pm/langchain/LangChain.Telemetry.md

Emits a telemetry event when the retriever starts fetching relevant documents. This is crucial for monitoring retrieval performance.

```elixir
@spec retriever_get_relevant_documents_start(map()) :: (map() -> :ok)

```

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

### Configure ChatReqLLM with Provider Options

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatReqLLM.md

Initializes ChatReqLLM with provider-specific options. This example shows how to pass 'thinking' options for Anthropic models.

```elixir
ChatReqLLM.new!(%{ 
  model: "anthropic:claude-haiku-4-5", 
  provider_opts: %{"thinking" => %{"type" => "enabled", "budget_tokens" => 2000}}
})
```

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

### Adapter Initialization and Usage

Source: https://hexdocs.pm/langchain_mcp/LangChain.MCP.Adapter.html

Demonstrates how to initialize the LangChain MCP Adapter with default and custom options, and how to use it within an LLMChain.

```APIDOC
## LangChain MCP Adapter API

### Description
This section details the core functionalities of the LangChain MCP Adapter for integrating MCP tools.

### Functions

#### `new(opts)`

##### Description
Creates a new MCP adapter.

##### Method
N/A (Function Call)

##### Parameters
- **opts** (keyword()) - Options for the adapter configuration. See `LangChain.MCP.Config.new!/1` for all available options.

##### Request Example
```elixir
# Define MCP client
defmodule MyApp.MCPClient do
  use Anubis.Client,
    name: "MyApp",
    version: "1.0.0",
    protocol_version: "2025-03-26"
end

# Create adapter with default options
adapter = Adapter.new(client: MyApp.MCPClient)

# Create adapter with custom options
adapter = Adapter.new(
  client: MyApp.MCPClient,
  cache_tools: true,
  timeout: 60_000,
  async: true,
  fallback_client: MyApp.BackupMCP,
  tool_filter: fn tool -> tool["name"] != "admin_only" end
)
```

#### `to_functions(adapter, opts \\ [])`

##### Description
Discovers tools from the MCP server and converts them to LangChain Functions.

##### Method
N/A (Function Call)

##### Parameters
- **adapter** (t()) - The adapter struct.
- **opts** (keyword()) - Optional keyword list:
  - **`:only`** (list(String.t())) - List of tool names to include.
  - **`:except`** (list(String.t())) - List of tool names to exclude.
  - **`:refresh`** (boolean()) - Force refresh cached tools (default: false).

##### Request Example
```elixir
# Get all tools
functions = Adapter.to_functions(adapter)

# Get specific tools
functions = Adapter.to_functions(adapter, only: ["search", "fetch"])
```

##### Response Example
```json
[
  {
    "name": "search",
    "description": "Search for information",
    "parameters": {
      "type": "object",
      "properties": {
        "query": {
          "type": "string",
          "description": "The search query"
        }
      },
      "required": ["query"]
    },
    "return_direct": false
  }
]
```

### Usage Example in LLMChain

```elixir
# Assuming 'model' is an initialized LLM and 'adapter' is created as above
chain = LLMChain.new!(%{llm: model})
  |> LLMChain.add_tools(Adapter.to_functions(adapter))
  |> LLMChain.run(mode: :while_needs_response)
```
```

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

### Registering a Callback Handler for LLMChain

Source: https://hexdocs.pm/langchain/LangChain.Chains.LLMChain.md

Register a callback handler to receive events during chain execution. This example shows how to get notified when an assistant response message is processed.

```elixir
live_view_pid = self()

handler = %{
  on_message_processed: fn _chain, message ->
    send(live_view_pid, {:new_assistant_response, message})
  end
}

LLMChain.new!(%{...})
|> LLMChain.add_callback(handler)
|> LLMChain.run()
```

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

### Use ChatDeepSeek with LLMChain

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatDeepSeek.md

Integrate the ChatDeepSeek model into an LLMChain for conversational AI tasks. This example shows how to create a chain, add a user message, and run the chain to get a response.

```elixir
# Using with LLMChain
    {:ok, chain} = 
      LLMChain.new!(%{llm: model}) 
      |> LLMChain.add_message(Message.new_user!("Hello!"))

    {:ok, response} = LLMChain.run(chain)
```

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

### FileOpenAI Initialization

Source: https://hexdocs.pm/langchain/LangChain.FileUploader.FileOpenAI.md

Demonstrates how to initialize the FileOpenAI uploader with API key and other configuration options.

```APIDOC
## `LangChain.FileUploader.FileOpenAI.new/1`

### Description
Setup an OpenAI file uploader configuration.

### Method
`new/1`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **attrs** (map) - Required - Attributes for the uploader configuration, including:
  - **api_key** (string) - Required - Your OpenAI API key.
  - **default_purpose** (string) - Optional - The default purpose for uploaded files.
  - **endpoint** (string) - Optional - The OpenAI API endpoint.
  - **receive_timeout** (integer) - Optional - Timeout for receiving responses.
  - **req_opts** (list) - Optional - Additional request options.

### Response
#### Success Response
- **{:ok, t()}** - Returns the initialized `FileOpenAI` struct on success.

#### Error Response
- **{:error, Ecto.Changeset.t()}** - Returns an Ecto changeset if the attributes are invalid.

### Example
```elixir
{:ok, uploader} = LangChain.FileUploader.FileOpenAI.new(%{api_key: "sk-...", default_purpose: "assistants"})
```
```

```APIDOC
## `LangChain.FileUploader.FileOpenAI.new!/1`

### Description
Setup an OpenAI file uploader configuration and return it or raise an error if invalid.

### Method
`new!/1`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **attrs** (map) - Required - Attributes for the uploader configuration, including:
  - **api_key** (string) - Required - Your OpenAI API key.
  - **default_purpose** (string) - Optional - The default purpose for uploaded files.
  - **endpoint** (string) - Optional - The OpenAI API endpoint.
  - **receive_timeout** (integer) - Optional - Timeout for receiving responses.
  - **req_opts** (list) - Optional - Additional request options.

### Response
#### Success Response
- **t()** - Returns the initialized `FileOpenAI` struct on success.

#### Error Response
- **no_return()** - Raises an error if the attributes are invalid.

### Example
```elixir
uploader = LangChain.FileUploader.FileOpenAI.new!(%{api_key: "sk-..."})
```
```

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

### Inspect Trajectory Tool Calls

Source: https://hexdocs.pm/langchain

Filter and group tool calls within a trajectory for detailed analysis. Examples include getting all calls for a specific tool or grouping calls by conversation turn.

```elixir
# All calls to a specific tool
Trajectory.calls_by_name(trajectory, "search")

# Group calls by conversation turn
Trajectory.calls_by_turn(trajectory)
#=> [{0, [%{name: "search", ...}]}, {1, [%{name: "get_forecast", ...}]}]

# Check aggregated token usage
trajectory.token_usage
#=> %TokenUsage{input: 150, output: 45}
```

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

### Initialize ChatOpenAI Client (Bang)

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatOpenAI.md

Sets up a ChatOpenAI client configuration and returns it. Raises an error if the configuration is invalid.

```elixir
@spec new!(attrs :: map()) :: t() | no_return()

```

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

### Initialize ChatOpenAI Client

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatOpenAI.md

Sets up a ChatOpenAI client configuration. Returns an :ok tuple with the configuration or an :error tuple with a changeset if invalid.

```elixir
@spec new(attrs :: map()) :: {:ok, t()} | {:error, Ecto.Changeset.t()}

```

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

### Initialize TextToTitleChain with {:ok, t()}

Source: https://hexdocs.pm/langchain/LangChain.Chains.TextToTitleChain.md

Example of creating a new TextToTitleChain configuration using the `new` function, which returns `{:ok, t()}` on success. Requires an LLM and input text.

```elixir
{:ok, chain} = TextToTitleChain.new(%{
  llm: %ChatOpenAI{model: "gpt-3.5-turbo", stream: false},
  input_text: "Let's create a marketing blog post about our new product 'Fuzzy Furries'"
})
```

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

### Initialize FileGoogle Uploader

Source: https://hexdocs.pm/langchain/LangChain.FileUploader.FileGoogle.md

Sets up a Google file uploader configuration. Use `new/1` for a successful return or `new!/1` to raise an error on invalid attributes.

```elixir
    {:ok, uploader} = LangChain.FileUploader.FileGoogle.new(%{api_key: "AI..."})
```

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

### LangChain Telemetry API - Usage Example

Source: https://hexdocs.pm/langchain/LangChain.Telemetry.md

Example of how to attach a handler to a specific telemetry event in your application.

```APIDOC
## Attaching to Telemetry Events

To attach to these events in your application:

```elixir
:telemetry.attach(
  "my-handler-id",
  [:langchain, :llm, :call, :stop],
  &MyApp.handle_llm_call/4,
  nil
)

def handle_llm_call(_event_name, measurements, metadata, _config) do
  # Process the event
  IO.inspect(measurements)
  IO.inspect(metadata)
end
```
```

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

### Bumblebee Text Generation Example

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatBumblebee.md

Example of generating text with Bumblebee, including options for streaming responses.

```elixir
Bumblebee.Text.generation(model_info, tokenizer, generation_config,
  # ...
  stream: true,
  stream_done: true
)
```

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

### ChatVertexAI `new` Function

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatVertexAI.md

Sets up a ChatVertexAI client configuration.

```APIDOC
## `new`

```elixir
@spec new(attrs :: map()) :: {:ok, t()} | {:error, Ecto.Changeset.t()}
```

### Description
Setup a ChatVertexAI client configuration.
```

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

### Initialize ChatGrok with Grok-3-mini and Callbacks

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatGrok.md

Example of initializing ChatGrok with the grok-3-mini model, including API key retrieval and callback handlers for real-time information.

```elixir
 {:ok, grok_mini} = ChatGrok.new(%{
  model: "grok-3-mini",
  temperature: 0.8,
  max_tokens: 5000,
  api_key: System.get_env("XAI_API_KEY"),
  callbacks: [handlers]
})
```

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

### TokenUsage Struct Example

Source: https://hexdocs.pm/langchain/LangChain.TokenUsage.md

An example of the TokenUsage struct, showing input, output, and raw token usage details.

```elixir
%TokenUsage{
  input: 30,
  output: 15,
  raw: %{
    "total_tokens" => 29
  }
}
```

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

### Create PromptTemplate from Template String

Source: https://hexdocs.pm/langchain/LangChain.PromptTemplate.md

Shows how to initialize a PromptTemplate using a string that includes EEx template syntax for parameter substitution.

```elixir
prompt = PromptTemplate.from_template!("What's a name for a company that makes <%= @product %>?")
```

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

### Example Usage of RoutingChain

Source: https://hexdocs.pm/langchain/LangChain.Chains.RoutingChain.md

Demonstrates how to set up and use the RoutingChain to select a route based on user input. Requires defining routes with names, descriptions, and associated chains, along with a default route.

```elixir
routes = [
  PromptRoute.new!(%{ 
    name: "marketing_email",
    description: "Create a marketing focused email",
    chain: marketing_email_chain
  }),
  PromptRoute.new!(%{ 
    name: "blog_post",
    description: "Create a blog post that will be linked from the company's landing page",
    chain: blog_post_chain
  }),
]

selected_route =
  RoutingChain.new!(%{ 
    llm: ChatOpenAI.new!(%{model: "gpt-40-mini", stream: false}),
    input_text: "Let's create a marketing blog post about our new product 'Fuzzy Furies'",
    routes: routes,
    default_route: PromptRoute.new!(%{name: "DEFAULT", chain: fallback_chain})
  })
  |> RoutingChain.evaluate()

# The PromptRoute for the `blog_post` should be returned as the `selected_route`.
```

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

### Trajectory Mismatch Failure Example

Source: https://hexdocs.pm/langchain/evaluation.md

Example of an informative failure message from `assert_trajectory` showing expected vs. actual tool calls.

```elixir
Trajectory mismatch (mode: strict, args: exact)

Expected:
[%{name: "search", arguments: %{"query" => "weather"}}]

Actual:
[%{name: "search", arguments: %{"query" => "news"}}]
```

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

### Tool Call Identified Example

Source: https://hexdocs.pm/langchain/LangChain.Chains.ChainCallbacks.md

Example of a callback handler for `chain_tool_call_identified`. It prints the identified tool's display text or name.

```elixir
callback_handler = %{
  on_tool_call_identified: fn _chain, tool_call, func ->
    IO.puts("Tool identified: #{func.display_text || tool_call.name}")
  end
}
```

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

### ChatReqLLM Initialization and Usage

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatReqLLM.md

Demonstrates how to initialize the ChatReqLLM adapter with different LLM providers and use it within an LLMChain. Includes examples for Anthropic, OpenAI, Ollama, and Groq, as well as streaming capabilities.

```APIDOC
## ChatReqLLM Initialization and Usage

### Description
This section shows how to initialize the `ChatReqLLM` adapter for various LLM providers and integrate it into a LangChain `LLMChain`. Examples cover common providers and streaming.

### Usage Examples

```elixir
alias LangChain.ChatModels.ChatReqLLM
alias LangChain.Chains.LLMChain
alias LangChain.Message

# Anthropic via req_llm
llm_anthropic = ChatReqLLM.new!(%{model: "anthropic:claude-haiku-4-5"})

# OpenAI
llm_openai = ChatReqLLM.new!(%{model: "openai:gpt-4o"})

# Ollama local model
llm_ollama = ChatReqLLM.new!(%{model: "ollama:llama3", base_url: "http://localhost:11434"})

# Groq with streaming
llm_groq_stream = ChatReqLLM.new!(%{model: "groq:llama-3.3-70b-versatile", stream: true})

# Example of running a chain
{:ok, chain} = 
  %{llm: llm_anthropic}
  |> LLMChain.new!()
  |> LLMChain.add_message(Message.new_user!("Hello!"))
  |> LLMChain.run()
```
```

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

### Calculator Tool Initialization

Source: https://hexdocs.pm/langchain/LangChain.Tools.Calculator.md

Demonstrates how to initialize the Calculator tool using `new` or `new!` functions.

```APIDOC
## Calculator Tool Initialization

### Description
Initializes the Calculator tool, which can be used to expose basic math calculation capabilities to an LLM.

### Functions

#### `new()`

```elixir
@spec new() :: {:ok, LangChain.Function.t()} | {:error, Ecto.Changeset.t()}
```

Defines the "calculator" function. Returns a success or failure response.

#### `new!()`

```elixir
@spec new!() :: LangChain.Function.t() | no_return()
```

Defines the "calculator" function. Raises an exception if function creation fails.
```

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

### Start Test Server on Custom Port

Source: https://hexdocs.pm/langchain_mcp/readme.html

Start the Elixir MCP test server on a custom port if the default port 5000 is in use.

```bash
mix test_server --port 5000

```

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

### Initialize TextToTitleChain with new! (raises error)

Source: https://hexdocs.pm/langchain/LangChain.Chains.TextToTitleChain.md

Example of creating a new TextToTitleChain configuration using `new!`, which returns the chain or raises an error if invalid. Requires an LLM and input text.

```elixir
chain = TextToTitleChain.new!(%{ 
  llm: %ChatOpenAI{model: "gpt-3.5-turbo", stream: false},
  input_text: "Let's create a marketing blog post about our new product 'Fuzzy Furries'"
})
```

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

### Configure MCP Adapter Options

Source: https://hexdocs.pm/langchain_mcp/index.html

Initialize an MCP adapter with various configuration options. These include caching, timeouts, async execution, fallback clients, and tool filtering.

```elixir
adapter = Adapter.new(
  client: MyApp.MCPClient,
  # Cache tool discovery (default: true)
  cache_tools: true,
  # Timeout for tool calls in ms (default: 30_000)
  timeout: 30_000,
  # Mark tools as async (default: false)
  async: false,
  # Fallback client if primary fails
  fallback_client: MyApp.BackupMCPClient,
  # Filter which tools to expose (default: all)
  tool_filter: fn tool -> tool["name"] not in ["dangerous_tool"] end
)
```

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

### Emit Tool Call Start Event

Source: https://hexdocs.pm/langchain/LangChain.Telemetry.md

Emits a tool call start event. This function is used to signal the beginning of a tool call operation.

```elixir
@spec tool_call_start(map()) :: (map() -> :ok)

Emits a tool call start event.
```

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

### Get Confirmation Callback

Source: https://hexdocs.pm/langchainex/LangChain.Anchor.Behavior.html

Use this callback to get a yes/no confirmation from the user. It's part of the Anchor behavior for validating AI chain outputs.

```Elixir
@callback get_confirmation() :: :yes | :no
```

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

### Summarize Conversation Chain Basic Example

Source: https://hexdocs.pm/langchain/LangChain.Chains.SummarizeConversationChain.md

A basic example demonstrating how to initialize and use the SummarizeConversationChain to process messages. It returns an updated chain with summarized contents.

```elixir
    {:ok, summarized_chain} =
      %{ 
        llm: ChatOpenAI.new!(%{model: "gpt-4o-mini", stream: false}),
        keep_count: 2,
        threshold_count: 6
      }
      |> SummarizeConversationChain.new!()
      |> SummarizeConversationChain.summarize(chain_to_summarize)
```

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

### ChatVertexAI `new!` Function

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatVertexAI.md

Sets up a ChatVertexAI client configuration and returns it, raising an error if the configuration is invalid.

```APIDOC
## `new!`

```elixir
@spec new!(attrs :: map()) :: t() | no_return()
```

### Description
Setup a ChatVertexAI client configuration and return it or raise an error if invalid.
```

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

### Emit Memory Read Start Event

Source: https://hexdocs.pm/langchain/LangChain.Telemetry.md

Emits a telemetry event to signify the start of a memory read operation. This is useful for monitoring memory access patterns.

```elixir
@spec memory_read_start(map()) :: (map() -> :ok)

```

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

### Create Adapter with Options

Source: https://hexdocs.pm/langchain_mcp/LangChain.MCP.Adapter.html

Create an MCP adapter with various configuration options, including enabling tool caching, setting timeouts, configuring asynchronous execution, specifying a fallback client, and applying a tool filter.

```elixir
adapter = Adapter.new(
  client: MyApp.MCPClient,
  cache_tools: true,
  timeout: 60_000,
  async: true,
  fallback_client: MyApp.BackupMCP,
  tool_filter: fn tool -> tool["name"] != "admin_only" end
)
```

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

### Emit Chain Execution Start Event

Source: https://hexdocs.pm/langchain/LangChain.Telemetry.md

Emits a telemetry event indicating the start of a chain execution. This function is part of the core telemetry events for LangChain.

```elixir
@spec chain_execute_start(map()) :: (map() -> :ok)

```

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

### Example Usage with LLMChain and Google Search

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatGoogleAI.md

Demonstrates how to use the ChatGoogleAI model within an LLMChain, including integrating the native Google Search tool.

```APIDOC
### Example Usage:

```elixir
alias LangChain.Chains.LLMChain
alias LangChain.Message
alias LangChain.NativeTool

model = ChatGoogleAI.new!(%{temperature: 0, stream: false, model: "gemini-2.0-flash"})

{:ok, updated_chain} =
   %{llm: model, verbose: false, stream: false}
   |> LLMChain.new!()
   |> LLMChain.add_message(
     Message.new_user!("What is the current Google stock price?")
   )
   |> LLMChain.add_tools(NativeTool.new!(%{name: "google_search", configuration: %{}}))
   |> LLMChain.run()
```

The above call will return the current Google stock price.

When `google_search` is used, the model will also return grounding information in the metadata attribute of the assistant message.
```

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

### Get Callback Definition

Source: https://hexdocs.pm/langchain/LangChain.FileUploader.md

Defines the callback signature for retrieving metadata of a previously uploaded file. It takes configuration and a file reference, returning a get result.

```elixir
@callback get(config :: struct(), file_ref :: LangChain.FileUploader.FileResult.t() | String.t()) ::
  get_result()
```

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

### LangChain.FileUploader.FileGoogle - Initialization

Source: https://hexdocs.pm/langchain/LangChain.FileUploader.FileGoogle.md

Initializes a Google file uploader configuration. The `new/1` function sets up the uploader with provided attributes, while `new!/1` does the same but raises an error if the attributes are invalid.

```APIDOC
## `LangChain.FileUploader.FileGoogle.new/1`

### Description
Setup a Google file uploader configuration.

### Method
`new`

### Parameters
#### Request Body
- **attrs** (map) - Required - Attributes for the uploader configuration, including `api_key`.

### Response
#### Success Response (200)
- **t()** (map) - A map representing the configured file uploader.

### Request Example
```elixir
%{
  api_key: "AI..."
}
```

## `LangChain.FileUploader.FileGoogle.new!/1`

### Description
Setup a Google file uploader configuration and return it or raise an error if invalid.

### Method
`new!`

### Parameters
#### Request Body
- **attrs** (map) - Required - Attributes for the uploader configuration, including `api_key`.

### Response
#### Success Response (200)
- **t()** (map) - A map representing the configured file uploader.

### Request Example
```elixir
%{
  api_key: "AI..."
}
```
```

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

### Custom LangchainPrompt Adapter Example

Source: https://hexdocs.pm/langchain_prompt/LangchainPrompt.Adapter.html

Implement this behaviour to add support for any LLM provider not covered by the built-in adapters. This example shows a basic structure for a custom adapter.

```elixir
defmodule MyApp.Adapters.OpenAIDirect do
  @behaviour LangchainPrompt.Adapter

  @impl true
  def chat(messages, opts) do
    # build request, call API, return {:ok, %Message{}} or {:error, reason}
  end
end
```

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

### Start Elixir MCP Test Server

Source: https://hexdocs.pm/langchain_mcp/readme.html

Start the built-in Elixir MCP test server for live integration tests. This server runs on http://localhost:5000 by default.

```bash
mix test_server

```

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

### Initialize and Use ChatVertexAI with LLMChain

Source: https://hexdocs.pm/langchain/LangChain.ChatModels.ChatVertexAI.md

Demonstrates how to configure and use the ChatVertexAI model within an LLMChain for analyzing file content. Ensure you have the necessary API key and timeout configurations.

```elixir
alias LangChain.Chains.LLMChain
alias LangChain.Message
alias LangChain.Message.ContentPart
alias LangChain.ChatModels.ChatVertexAI

config = %{
      model: "gemini-2.0-flash",
      api_key: ..., # vertex requires gcloud auth token https://cloud.google.com/vertex-ai/generative-ai/docs/start/quickstarts/quickstart-multimodal#rest
      temperature: 1.0,
      top_p: 0.8,
      receive_timeout: ...
    }
 model = ChatVertexAI.new!(config)

    %{llm: model, verbose: false, stream: false}
    |> LLMChain.new!()
    |> LLMChain.add_message(
      Message.new_user!([
        ContentPart.new!(%{type: :text, content: "Analyse the provided file and share a summary"}),
        ContentPart.new!(
          %{type: :file_url, content: ..., options: [media: ...]}
        )
      ])
    )
    |> LLMChain.run()
The above call will return summary of the media content.
```

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

### Initialize ChatGPT Model for Image Analysis

Source: https://hexdocs.pm/langchain/context-specific-image-descriptions.md

Set up the ChatOpenAI model for interacting with ChatGPT. Use the "gpt-4o" model, which is required for image support at the time of this writing. The response is configured not to stream.

```elixir
alias LangChain.ChatModels.ChatOpenAI

openai_chat_model = ChatOpenAI.new!(%{model: "gpt-4o"})
```

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

### Start LangChain MCP Test Server on Custom Port

Source: https://hexdocs.pm/langchain_mcp/Mix.Tasks.TestServer.html

Starts the MCP test server on a custom port. This is useful for running multiple instances or avoiding port conflicts.

```bash
mix test_server --port 4001
```
Tokens:
Raw