Edit Post

Title*

Author*

Description

Publication Date

Tags

Separate tags with commas

Content*

## The Problem

Implementing a conversational agent that can call domain‑specific APIs (e.g., adding items to a packlist or querying gym data) requires a clean way to expose those actions to an LLM. LangGraph’s tool‑binding and routing make it possible to interleave LLM text generation with concrete tool executions inside a single graph.

* * *

## Services and Libraries

-   **Tool** – Declares a callable function with name, description, and implementation.
    
-   **ToolNode** – Executes any tool calls found in the LLM output.
    
-   **init\_chat\_model** – Instantiates a Gemini‑based chat model.
    
-   **StateGraph** – Builds a state machine where nodes can be LLM or tool invocations.
    
-   **CompiledStateGraph** – The runnable, compiled version of the graph.

See the code on github, [https://github.com/bernatsampera/langgraph-playground/tree/main/examples/introduction/custom\_tools\_chatbot](https://github.com/bernatsampera/langgraph-playground/tree/main/examples/introduction/custom_tools_chatbot)

* * *

## Implementation Details of the Topic

### 1\. Define domain tools

Create one‑liner functions that interact with the external API, then wrap them in `Tool` objects.

```python
# Example code
def show_gyms_city(city: str) -> list:
    """Retrieve a list of gyms in the specified city."""
    print(f"Showing gyms in {city}")
    return ["Gym 1", "Gym 2", "Gym 3"]

def show_gym_details(gym_name: str) -> str:
    """Retrieve details for a specific gym."""
    print(f"Showing details for {gym_name}")
    return f"{gym_name} is a great gym"

tools = [
    Tool(
        name="show_gyms_city",
        description="List available gyms in a specified city",
        func=show_gyms_city,
    ),
    Tool(
        name="show_gym_details",
        description="Show detailed information about a specific gym",
        func=show_gym_details,
    ),
]
```

### 2\. Bind tools to the LLM

Attach the tool list to the chat model so it can emit calls in its output.

```python
# Example code
llm = init_chat_model("google_genai:gemini-2.5-flash-lite")
llm_with_tools = llm.bind_tools(tools)
```

### 3\. Create the ToolNode

Instantiate a node that will run any tool calls the LLM produces.

```python
# Example code
tool_node = ToolNode(tools)
```

### 4\. Chatbot node

The node that sends the current conversation state to the LLM and returns the LLM’s response.

```python
# Example code
def chatbot(state: State) -> dict:
    """Process the state and generate a response using the LLM."""
    return {"messages": [llm_with_tools.invoke(state["messages"])]}
```

### 5\. Routing logic

Decide whether to send the output to the tool node or terminate the dialogue.

```python
# Example code
def should_continue(state: State) -> str:
    """Determine whether to route to the tools node or end the conversation."""
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END
```

### 6\. Build and compile the graph

Add the nodes and conditional edges, then compile for execution.

```python
# Example code
def build_graph() -> CompiledStateGraph:
    """Create and configure the state graph for the chatbot."""
    graph_builder = StateGraph(State)
    graph_builder.add_node("chatbot", chatbot)
    graph_builder.add_node("tools", tool_node)
    graph_builder.add_edge(START, "chatbot")
    graph_builder.add_conditional_edges("chatbot", should_continue)
    graph_builder.add_edge("tools", "chatbot")
    compiled_graph = graph_builder.compile()
    return compiled_graph
```

By following these steps, a LangGraph‑based chatbot can seamlessly integrate custom domain tools, enabling the LLM to delegate actionable tasks while maintaining conversational flow.

Cancel