Idun Agent Platform

https://docs.idun-group.com
Admin
Open-source production wrapper for LangGraph and Google ADK agents with chat UI, traces, guardrails,...
Tokens:48,680
Snippets:728
Trust Score:5.4
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Configure Environment

Source: https://docs.idun-group.com/templates

Install project dependencies using pip and copy the example environment file. Edit the .env file to include your API keys.

```bash
pip install -r requirements.txt
cp .env.example .env
# Edit .env with your API keys
```

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

### Local development setup from checkout

Source: https://docs.idun-group.com/standalone/quickstart

Clone the idun-agent-platform repository and set up the development environment. This includes installing dependencies, building the standalone components, and serving the agent.

```bash
git clone https://github.com/Idun-Group/idun-agent-platform.git
cd idun-agent-platform
make sync                # Install all Python deps via uv
make build-standalone-all  # Build the UI and the wheel
IDUN_CONFIG_PATH=path/to/your/config.yaml uv run idun serve
```

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

### Final Configuration Example

Source: https://docs.idun-group.com/observability/custom-handler

Example `config.yaml` showing the provider and configuration details for the OTLP handler.

```yaml
observability:
  - provider: "OTLP"
    enabled: true
    config:
      endpoint: "https://otlp.example.com/v1/traces"
      api_key: "${OTLP_API_KEY}"
```

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

### Setup and Serve Existing Project

Source: https://docs.idun-group.com/cli/overview

For existing projects, this performs one-time setup including migrations and database seeding. Then, it serves the application locally.

```bash
# IDUN_CONFIG_PATH points at config.yaml (default ./config.yaml)
idun setup     # one-time: migrations + seed the DB
idun serve     # bind 127.0.0.1:8000, admin at /admin/, traces at /admin/traces/
```

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

### Install Idun Engine and Dependencies

Source: https://docs.idun-group.com/guides/deepagents-with-idun

Set up a Python virtual environment and install the Idun Engine, standalone runtime, and Google GenAI dependencies required for the Deep Agent example.

```bash
uv venv --python 3.12
source .venv/bin/activate
uv pip install -e .
uv pip install idun-agent-engine idun-agent-standalone langchain-google-genai
```

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

### Install and Initialize Idun Assistant

Source: https://docs.idun-group.com/guides/idun-assistant-copilot

Commands to install the idun-agent-engine, set up the environment, and initialize the standalone Idun application.

```bash
pip install idun-agent-engine
cd idun-assistant
cp .env.example .env       # fill in GEMINI_API_KEY (or your provider's key)
idun init
```

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

### Install and Run Idun Agent Engine

Source: https://docs.idun-group.com/frameworks/adk

Install the necessary packages and run the Idun agent engine. The first boot initializes the database and serves the chat UI.

```bash
pip install idun-agent-engine google-adk
idun serve
```

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

### Install and Initialize Idun Agent Engine

Source: https://docs.idun-group.com/glossary

Installs the idun-agent-engine package and initializes a new agent project. This command also sets up the database and opens the browser to the onboarding wizard.

```bash
pip install idun-agent-engine
mkdir my-agent && cd my-agent
idun init
```

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

### Install and Run Idun Agent Engine

Source: https://docs.idun-group.com/frameworks/langgraph

Install the necessary packages and run the Idun agent engine. The engine will read the configuration file and serve the chat UI.

```bash
pip install idun-agent-engine langgraph langchain-openai
idun serve
```

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

### Install Idun Agent Engine (Standard)

Source: https://docs.idun-group.com/changelog/overview

Use this command for a standard installation of the Idun agent engine. Ensure you have pip installed.

```bash
pip install idun-agent-engine==0.6.0
```

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

### Complete Engine Configuration Example

Source: https://docs.idun-group.com/configuration

This example demonstrates a comprehensive EngineConfig YAML file, showcasing settings for server, agent, observability, guardrails, MCP servers, prompts, SSO, and integrations. It includes environment variable placeholders for sensitive information.

```yaml
server:
  api:
    port: 8001

agent:
  type: "LANGGRAPH"
  config:
    name: "Support Agent"
    graph_definition: "./agent.py:graph"
    checkpointer:
      type: "sqlite"
      db_url: "sqlite:///checkpoints.db"

observability:
  - provider: "LANGFUSE"
    enabled: true
    config:
      host: "https://cloud.langfuse.com"
      public_key: "${LANGFUSE_PUBLIC_KEY}"
      secret_key: "${LANGFUSE_SECRET_KEY}"

guardrails:
  input:
    - config_id: "DETECT_PII"
      on_fail: "reject"
      reject_message: "Request contains personal information."
  output:
    - config_id: "TOXIC_LANGUAGE"
      on_fail: "reject"

mcp_servers:
  - name: "time"
    transport: "stdio"
    command: "docker"
    args: ["run", "-i", "--rm", "mcp/time"]

prompts:
  - prompt_id: "system-prompt"
    version: 1
    content: "You are a support agent for {{ company_name }}".
    tags: ["latest"]

sso:
  enabled: true
  issuer: "https://accounts.google.com"
  client_id: "123456789.apps.googleusercontent.com"
  allowed_domains: ["yourcompany.com"]

integrations:
  - provider: "WHATSAPP"
    enabled: true
    config:
      access_token: "${WHATSAPP_ACCESS_TOKEN}"
      phone_number_id: "${WHATSAPP_PHONE_ID}"
      verify_token: "${WHATSAPP_VERIFY_TOKEN}"
```

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

### Start Idun Server Programmatically (CLI)

Source: https://docs.idun-group.com/guides/connect-your-agent

Command to execute the Python script that programmatically starts the Idun agent engine.

```bash
python serve.py
```

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

### CLI Startup Warning Examples

Source: https://docs.idun-group.com/troubleshooting

These warnings are from upstream packages and do not impact current functionality. They are expected to be filtered in future releases.

```text
LangChain allowed_objects deprecation
LiteLLM Bedrock missing
LiteLLM SageMaker missing
```

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

### Configuration with Environment Variables

Source: https://docs.idun-group.com/observability/custom-handler

Example YAML configuration demonstrating how to use environment variables for sensitive settings like endpoint and API key.

```yaml
observability:
  - provider: "OTLP"
    enabled: true
    config:
      endpoint: "${OTLP_ENDPOINT}"
      api_key: "${OTLP_API_KEY}"
```

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

### Run Database Migrations

Source: https://docs.idun-group.com/deployment/hardening

Execute the `idun setup` command to automatically run Alembic migrations and set up the database schema. This should be run once against the production database.

```bash
idun setup
```

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

### Start Idun Server

Source: https://docs.idun-group.com/guides/langgraph-production-deployment

Sets the Gemini API key environment variable and starts the Idun agent engine server. This command makes the deployed agent accessible via HTTP.

```bash
export GEMINI_API_KEY="AIzaSy-replace-with-your-gemini-key"
idun serve
```

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

### Clone Deep Agents Example and Download Database

Source: https://docs.idun-group.com/guides/deepagents-with-idun

Clone the official text-to-SQL Deep Agent example repository and download the necessary SQLite database for the agent to query.

```bash
git clone https://github.com/langchain-ai/deepagents.git
cd deepagents/examples/text-to-sql-agent

# Download the demo database
curl -L -o chinook.db \
  https://github.com/lerocha/chinook-database/raw/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite
```

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

### Initialize Idun Agent Engine (CLI)

Source: https://docs.idun-group.com/guides/connect-your-agent

Command to initialize the Idun agent engine, setting up the database and starting the application for local development.

```bash
idun init
```

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

### Install idun-agent-engine

Source: https://docs.idun-group.com/standalone/quickstart

Install the idun-agent-engine package using pip. This command installs the engine, standalone apps, and the console script.

```bash
pip install idun-agent-engine
```

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

### Graph Load Error Examples

Source: https://docs.idun-group.com/troubleshooting

These exceptions indicate issues with loading the graph definition. Ensure the path or module exists, the variable is a StateGraph, and langgraph is installed.

```text
FileNotFoundError: graph_definition path does not exist: <path>
ModuleNotFoundError: No module named '<module>'
ImportError: cannot import name '<variable>' from '<module>'
TypeError: graph_definition must resolve to a StateGraph or CompiledStateGraph
```

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

### Install Idun Agent Engine with Guardrails

Source: https://docs.idun-group.com/changelog/overview

Use this command to install the Idun agent engine with Guardrails-AI support. Ensure you have pip installed.

```bash
pip install idun-agent-engine[guardrails]==0.6.0
```

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

### Install Idun Engine and Dependencies

Source: https://docs.idun-group.com/guides/langgraph-production-deployment

Installs the Idun agent engine and the necessary Langchain Google Generative AI package. This command ensures all required libraries are available for running the agent.

```bash
pip install idun-agent-engine langchain-google-genai
```

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

### Setup Idun database schema

Source: https://docs.idun-group.com/standalone/cli

Creates the database schema and seeds it from a YAML file if the database is empty. This is automatically called by 'serve' and 'init', but can be run manually to pre-stage migrations.

```bash
idun setup --config <path>
```

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

### Configure Idun Environment Variables

Source: https://docs.idun-group.com/guides/deepagents-with-idun

Copy the example environment file and configure Idun's settings, including paths, authentication, and LLM API keys. Ensure to generate and paste the required secrets for admin password hash and session secret.

```bash
cp .env.example .env
```

```dotenv
# Idun standalone
IDUN_CONFIG_PATH=./config.yaml
IDUN_AGENT_CONFIG_PATH=./config.yaml
IDUN_ALLOW_OPEN_ADMIN=1
IDUN_ADMIN_AUTH_MODE=password
IDUN_ADMIN_PASSWORD_HASH=${IDUN_ADMIN_PASSWORD_HASH}    # paste the output of `idun hash-password`
IDUN_SESSION_SECRET=${IDUN_SESSION_SECRET}              # paste the output of `openssl rand -hex 32`

# LLM
GEMINI_API_KEY=${GEMINI_API_KEY}                        # export your real Gemini API key in your shell
```

```bash
idun hash-password            # prompts, prints a bcrypt hash → IDUN_ADMIN_PASSWORD_HASH
openssl rand -hex 32          # → IDUN_SESSION_SECRET
```

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

### Serve Idun Agent Engine (CLI)

Source: https://docs.idun-group.com/guides/connect-your-agent

Command to start the Idun agent engine after initialization. This command assumes the `IDUN_CONFIG_PATH` environment variable is set or defaults to `./config.yaml`.

```bash
idun serve
```

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

### Configure Observability with Langfuse in config.yaml

Source: https://docs.idun-group.com/observability/overview

Add an 'observability' section to your config.yaml to enable and configure providers. This example shows how to set up Langfuse with its public and secret keys and host.

```yaml
observability:
  - provider: "LANGFUSE"
    enabled: true
    config:
      public_key: "pk-lf-..."
      secret_key: "sk-lf-..."
      host: "https://cloud.langfuse.com"
```

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

### Start Google Workspace MCP Server

Source: https://docs.idun-group.com/guides/deepagents-with-idun

Run the Google Workspace MCP server locally using uvx. The server will provide an OAuth URL on first connect for consent flow.

```bash
uvx workspace-mcp --transport streamable-http --port 8000
```

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

### Curl Example for /agent/run

Source: https://docs.idun-group.com/guides/programmatic-chat

Use this curl command to send a request to the /agent/run endpoint. Ensure all required fields in the AG-UI RunAgentInput shape are present.

```bash
curl -N -X POST http://127.0.0.1:8000/agent/run \
  -H "Content-Type: application/json" \
  -d '{
    "threadId": "demo-1",
    "runId": "run-1",
    "state": {},
    "messages": [
      {"id":"msg-1","role":"user","content":"Hello"}
    ],
    "tools": [],
    "context": [],
    "forwardedProps": {}
  }'
```

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

### Configure Guardrails for Input and Output

Source: https://docs.idun-group.com/guardrails/reference

Example of how to configure guardrails for both input and output positions in your application. This includes specifying the guardrail type, a reject message, and type-specific configurations.

```yaml
guardrails:
  input:
    - config_id: detect_pii
      reject_message: "PII detected in your input"
      pii_entities: ["EMAIL_ADDRESS", "PHONE_NUMBER", "CREDIT_CARD"]
      on_fail: exception

  output:
    - config_id: toxic_language
      reject_message: "Response contains inappropriate language"
      threshold: 0.7
```

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

### Graph Definition Format Examples

Source: https://docs.idun-group.com/guides/connect-your-agent

Illustrates different ways to specify the agent's definition path in the `config.yaml`. It can be a file path or a Python module path.

```yaml
# File path (relative or absolute)
graph_definition: "./my_agent.py:graph"
graph_definition: "src/agents/router.py:app"

# Python module path (when your package is importable)
graph_definition: "my_package.agents.router:graph"
```

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

### Set Guardrails API Key and Serve Agent

Source: https://docs.idun-group.com/guides/langgraph-production-deployment

Set the GUARDRAILS_API_KEY environment variable and then start the Idun server. The server will download and initialize the specified guardrail validators upon startup.

```bash
export GUARDRAILS_API_KEY="grdrls_replace-with-your-guardrails-key"
idun serve
```

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

### Combined Input and Output Guardrails

Source: https://docs.idun-group.com/guardrails/overview

Configure both input and output guardrails in a single `config.yaml` file. This example includes guardrails for detecting jailbreaks, prompt injections, and RAG hallucinations.

```yaml
guardrails:
  input:
    - config_id: "detect_jailbreak"
      threshold: 0.8
    - config_id: "prompt_injection"
      threshold: 0.8
  output:
    - config_id: "rag_hallucination"
      threshold: 0.7
```

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

### Generate Bcrypt Hash and Serve

Source: https://docs.idun-group.com/auth/overview

Use this command to generate a bcrypt hash for the admin password and then start the server with password authentication enabled. Ensure you generate the hash on a secure workstation.

```bash
idun hash-password
# Password: ********
# Confirm:  ********
# $2b$12$abc...   <- copy this

IDUN_ADMIN_AUTH_MODE=password \
IDUN_ADMIN_PASSWORD_HASH='$2b$12$abc...' \
IDUN_SESSION_SECRET="$(openssl rand -hex 32)" \
idun serve
```

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

### Serve Idun Agent in Engine-Only Mode

Source: https://docs.idun-group.com/glossary

Starts the Idun Agent in engine-only mode, suitable for environments where only the runtime layer is needed without the standalone UI or database. This command requires a configuration file.

```bash
idun agent serve --source file --path config.yaml
```

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

### Run an engine-only server

Source: https://docs.idun-group.com/standalone/cli

Starts an engine-only server without a database or admin interface. This is useful for integrating with existing admin stacks. The `--source` must be 'file' and requires a `--path` to the configuration YAML.

```bash
idun agent serve --source file --path ./config.yaml
```

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

### Python Example for Explicit Schema Agent

Source: https://docs.idun-group.com/guides/programmatic-chat

Define input and output schemas for a LangGraph agent using TypedDict. This enables structured-mode agents where messages must be valid JSON matching the input schema.

```python
from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class InputState(TypedDict):
    user_input: str

class OutputState(TypedDict):
    graph_output: str

class OverallState(TypedDict):
    user_input: str
    intermediate: str
    graph_output: str

builder = StateGraph(
    OverallState,
    input_schema=InputState,
    output_schema=OutputState,
)
```

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

### Create and Initialize New Project

Source: https://docs.idun-group.com/cli/overview

Use this to scaffold a new agent project and run initial migrations. It opens an onboarding wizard in the browser.

```bash
mkdir my-agent && cd my-agent
idun init
```

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

### Graceful Initialization with Error Handling

Source: https://docs.idun-group.com/observability/custom-handler

Wrap handler initialization in a try-except block to prevent initialization failures from crashing the agent boot. Log any exceptions encountered.

```python
def __init__(self, options: dict | None = None) -> None:
    try:
        # ... init client ...
        self._callbacks = [build_callback()]
    except Exception as exc:
        logger.exception("Failed to init my observability provider: %s", exc)
        self._callbacks = []
```

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

### Convert Prompt to LangChain PromptTemplate

Source: https://docs.idun-group.com/prompts

Converts an Idun prompt object into a LangChain PromptTemplate for integration with LangChain applications. Requires the 'langchain-core' library to be installed.

```python
prompt = get_prompt("rag-query")
lc_prompt = prompt.to_langchain()

result = lc_prompt.format(context="AI is...", query="What is AI?")
```

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

### Build and Push Docker Image

Source: https://docs.idun-group.com/standalone/cloud-run

Build a Docker image using a Dockerfile and push it to Google Container Registry. Replace 'PROJECT' and the image tag with your specific details.

```bash
docker build -f Dockerfile.example -t gcr.io/PROJECT/my-agent:0.1.0 .
docker push gcr.io/PROJECT/my-agent:0.1.0
```

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

### Get a prompt

Source: https://docs.idun-group.com/prompts

Retrieves a prompt by its ID and formats it with provided variables. Supports resolution through explicit config path, in-process snapshot, or environment variables.

```APIDOC
## Get Prompt (SDK)

### Description
Retrieves a prompt by its ID and formats it with provided variables.

### Method
`get_prompt(prompt_id: str)`

### Parameters
- **prompt_id** (string) - Required - The identifier for the prompt to retrieve.

### Usage Example
```python
from idun_agent_engine.prompts import get_prompt

prompt = get_prompt("system-prompt")
rendered = prompt.format(domain="healthcare")
```

<Warning>
`format()` uses Jinja2 strict mode. Missing variables raise a `ValueError` with a message including the prompt ID and version.
</Warning>
```

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

### Pull Fetch MCP Server Image

Source: https://docs.idun-group.com/mcp-servers/docker-toolkit

Use this command to download the Fetch MCP server Docker image. Ensure Docker Desktop is installed and running.

```bash
docker pull mcp/fetch
```

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

### Open API Documentation

Source: https://docs.idun-group.com/cli/overview

Access the OpenAPI schema documentation for the running standalone agent. The command to open the documentation varies by operating system.

```bash
# macOS
open http://localhost:8000/docs

# Linux
xdg-open http://localhost:8000/docs

# Windows (cmd)
start http://localhost:8000/docs
```

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

### System Prompt for Idun Assistant

Source: https://docs.idun-group.com/guides/idun-assistant-copilot

Defines the persona, behavior, and rules for the Idun Assistant. Use this prompt to guide the agent's interactions and tool usage.

```text
You are Idun's in-house dev assistant. You hang out in Discord and Google
Chat, helping the team get things done, looking up Jira tickets, reading
docs (idun-docs MCP), drafting messages, finding files in Drive, opening
PRs, whatever fits the tools bound to your toolset right now.

You sound like a sharp colleague, not a corporate chatbot. Direct, dry,
a little wry. No "I hope this helps!" sign-offs, no apologetic preambles,
no flattery. If something is a bad idea, say so. If a question is genuinely
ambiguous, ask once, briefly, then move on.

Behavioral rules:
- Use the bound tools when they fit. Only call tools that appear in your
  tool set. Never invent tool names or arguments.
- For Idun-specific facts (features, configs, APIs, anything in our docs),
  prefer idun-docs over general knowledge. For repo facts, use github.
  For tickets and Confluence pages, use atlassian.
- Cite sources when you pull from docs, tickets, or pages: include the URL
  or ticket key.
- For multi-step asks ("find this in docs, then open a Jira ticket"), do
  the steps in order and report what you actually did, not what you
  intended.
- When you don't know, say "I don't know" instead of guessing.
```

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

### Serve with Password Authentication

Source: https://docs.idun-group.com/cli/overview

Configure password authentication for the agent by hashing a password and setting environment variables for authentication mode, password hash, and session secret before serving.

```bash
HASH=$(idun hash-password)
SECRET=$(openssl rand -hex 32)
IDUN_ADMIN_AUTH_MODE=password \
IDUN_ADMIN_PASSWORD_HASH="$HASH" \
IDUN_SESSION_SECRET="$SECRET" \
idun serve
```

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

### Create LangGraph Project Directory

Source: https://docs.idun-group.com/guides/langgraph-production-deployment

Sets up the necessary directory structure for a LangGraph project. This includes creating a main project folder and an agent sub-directory with an initialization file.

```bash
mkdir langgraph-prod && cd langgraph-prod
mkdir agent && touch agent/__init__.py
```

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

### PostgreSQL Memory Configuration for Production

Source: https://docs.idun-group.com/guides/idun-assistant-copilot

Swap to PostgreSQL for persistent conversation memory in production environments with multiple replicas. The agent code remains unchanged.

```text
postgresql://...
```

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

### Get and Render a Prompt in Python

Source: https://docs.idun-group.com/prompts

Retrieves a prompt by its ID and formats it with provided variables. Jinja2 strict mode is used, so all variables must be present or a ValueError will be raised.

```python
from idun_agent_engine.prompts import get_prompt

prompt = get_prompt("system-prompt")
rendered = prompt.format(domain="healthcare")
# "You are a helpful assistant for healthcare."
```

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

### Configure MCP Servers in YAML

Source: https://docs.idun-group.com/mcp-servers/overview

Define MCP servers in your config.yaml file. This example shows configurations for 'stdio' and 'streamable_http' transports, including command, arguments, and environment variables.

```yaml
mcp_servers:
  - name: fetch
    transport: stdio
    command: docker
    args: ["run", "-i", "--rm", "mcp/fetch"]

  - name: filesystem
    transport: stdio
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/data"]
    env:
      ALLOWED_DIRECTORY: /data

  - name: custom-api
    transport: streamable_http
    url: https://mcp.example.com/api
    headers:
      Authorization: "Bearer ${MCP_API_TOKEN}"
```

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

### LangGraph Agent Configuration (YAML)

Source: https://docs.idun-group.com/frameworks/langgraph

Configure a LangGraph agent by setting the agent type to LANGGRAPH and specifying the graph definition file and variable. This example uses in-memory checkpointing.

```yaml
server:
  api:
    port: 8000

agent:
  type: LANGGRAPH
  config:
    name: "my-langgraph-agent"
    graph_definition: "my_agent/agent.py:graph"
    checkpointer:
      type: memory
```

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

### Python Example for Implicit State Agent

Source: https://docs.idun-group.com/guides/programmatic-chat

Define an agent state with messages and internal carry-fields without an explicit input schema. This defaults to chat mode, allowing plain-text content.

```python
class AgentState(TypedDict, total=False):
    messages: list[BaseMessage]
    intent: str
    draft: str
    response: str

builder = StateGraph(AgentState)  # no input_schema, chat mode
```

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

### Load ADK Tools with get_adk_tools

Source: https://docs.idun-group.com/mcp-servers/overview

Use `get_adk_tools()` to load all MCP servers attached to your agent. No individual tool configuration is needed.

```python
from idun_agent_engine.mcp import get_adk_tools

idun_tools = get_adk_tools()
```

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

### Test Agent API with cURL

Source: https://docs.idun-group.com/guides/connect-your-agent

Example using cURL to send a POST request to the agent's run endpoint. This demonstrates how to interact with the agent API, providing a thread ID and messages.

```bash
curl -X POST http://localhost:8000/agent/run \
  -H "Content-Type: application/json" \
  -d '{
    "thread_id": "test-1",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

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

### Configure Docker Logging Driver

Source: https://docs.idun-group.com/mcp-servers/docker-toolkit

Set up Docker logging drivers and options for better observability of container activity.

```json
["run", "-i", "--rm", "--log-driver=json-file", "--log-opt=max-size=10m", "mcp/fetch"]
```

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

### LangGraph Agent with Tool Calling

Source: https://docs.idun-group.com/guides/langgraph-production-deployment

Defines a LangGraph agent that utilizes tool calling capabilities with the Gemini model. It includes example tools for addition and multiplication, and defines the graph's execution flow.

```python
import os

from langchain_core.tools import tool
from langchain_google_genai import ChatGoogleGenerativeAI
from langgraph.graph import MessagesState, START, StateGraph
from langgraph.prebuilt import tools_condition


@tool
def add(a: float, b: float) -> float:
    """Add two numbers together."""
    return a + b


@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers together."""
    return a * b


model = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash",
    google_api_key=os.getenv("GEMINI_API_KEY"),
)

tools = [add, multiply]


async def call_model(state: MessagesState):
    model_with_tools = model.bind_tools(tools)
    response = await model_with_tools.ainvoke(state["messages"])
    return {"messages": [response]}


async def call_tools(state: MessagesState):
    from langchain_core.messages import ToolMessage

    tools_by_name = {t.name: t for t in tools}
    last_message = state["messages"][-1]
    results = []
    for tool_call in last_message.tool_calls:
        t = tools_by_name[tool_call["name"]]
        result = await t.ainvoke(tool_call["args"])
        results.append(
            ToolMessage(
                content=str(result),
                tool_call_id=tool_call["id"],
                name=tool_call["name"],
            )
        )
    return {"messages": results}


workflow = StateGraph(MessagesState)
workflow.add_node("call_model", call_model)
workflow.add_node("tools", call_tools)
workflow.add_edge(START, "call_model")
workflow.add_conditional_edges("call_model", tools_condition)
workflow.add_edge("tools", "call_model")

```
Tokens:
Raw