Interactive NotebookBuilding Intelligent Agents with LangChain and LangGraph: Part 1 - Core Concepts

Introduction

This is the first article in a series exploring how to build intelligent agents with LangChain and LangGraph. We'll start with the fundamental concepts that form the foundation of all agent-based systems.

Modern AI applications often need to do more than just generate text - they need to take actions in the real world. LLM workflows enable language models to interact with external systems by giving them access to tools and functions.

In this foundational guide, you'll learn the core building blocks:

• How to connect language models to external tools
• Design robust tool schemas that models can understand
• Handle tool responses and create reliable workflows
• Build systems that feel natural and intelligent

Let's start by setting up our environment and understanding these essential concepts.

Setting Up the Environment

First, we'll import the essential components for building our agentic workflow:

• init_chat_model for initializing language models
• tool decorator for creating callable functions

Initializing the Language Model

The init_chat_model function provides a unified interface for working with different language model providers. Here we're using Google's Vertex AI with the Gemini 2.0 Flash model, which offers a good balance of speed and capability for agentic tasks.

The temperature=0 setting ensures deterministic outputs, which is important for reliable tool usage.

Note: While temperature=0 aims for more deterministic outputs, LLMs often end up being non-deterministic due to various factors. For a deeper understanding of this topic, see Why LLMs Are Not Deterministic.

Let's test our model with a simple interaction to ensure it's working correctly. The response comes back as an AIMessage object, which is LangChain's standard format for model outputs.

Creating Tools for Our Agent

Tools are the bridge between language models and external actions. The @tool decorator automatically converts a Python function into a format that language models can understand and invoke.

Our write_email function demonstrates the key principles of good tool design:

• Clear purpose: The function does one thing well
• Type annotations: Parameters have explicit types for validation
• Descriptive docstring: Helps the model understand when and how to use the tool
• Return value: Provides feedback about the action taken

In a real application, this would integrate with an email service like SendGrid or Gmail API.

Understanding Tool Schemas

The @tool decorator automatically generates a JSON schema that describes the function's parameters. This schema is what the language model uses to understand how to call the tool correctly.

Let's examine the generated schema to see how our type annotations are converted into a format the model can understand:

Connecting Tools to the Language Model

Now comes the crucial step: binding our tools to the language model. This creates an enhanced model that can both generate text and make tool calls when appropriate.

The bind_tools method configures how the model should interact with our tools:

• tool_choice="any" forces the model to choose at least one tool
• parallel_tool_calls=False ensures tools are called sequentially for predictable behavior

Testing the Agent

Let's test our tool-enabled model with a natural language request. Notice how we can give the model a high-level instruction, and it automatically decides to use the email tool with appropriate parameters.

Examining the Tool Call Response

The model's response contains rich metadata about the tool call it wants to make. The tool_calls array shows us exactly what the model intends to do:

• Which tool to call (write_email)
• What arguments to pass
• A unique ID for tracking the call

This structured approach ensures reliable execution and makes it easy to handle complex multi-step workflows.

Let's extract the arguments the model wants to pass to our tool. Notice how it inferred reasonable values for all required parameters based on our natural language request.

Executing the Tool

Finally, we can execute the actual tool with the model's proposed arguments. This completes the agentic workflow: from natural language instruction to structured tool call to real-world action.

Key Takeaways

You've just built the foundation for intelligent AI systems that can take real-world actions. This LLM workflow pattern forms the core of all agent-based applications.

What you've mastered:

• Creating tools that language models can understand and invoke
• Binding tools to models for seamless integration
• Handling structured tool calls and responses
• Building reliable workflows from natural language to actions

Where to go next: Part Two of this series will explore agentic workflows - systems that are not fully autonomous yet, but can plan, reason, and execute multi-step tasks autonomously. While this article focused on the fundamentals of LLM workflows, the next will show you how to build a more sophisticated solution.

Putting It All Together

Let's create a minimal CLI tool that demonstrates everything we've learned. Save this as email_agent.py and run it from your terminal:

1#!/usr/bin/env python3
2from langchain.chat_models import init_chat_model
3from langchain.tools import tool
4
5@tool
6def email_tool(to: str, subject: str, content: str) -> str:
7    """Draft email and send."""
8    # Placeholder: we'd use an actual mailing service here
9    return f"Email sent to: {to} | Subject: {subject} | Content: {content}"
10
11def main():
12    # Initialize model
13    llm = init_chat_model(
14        "google_vertexai:gemini-2.0-flash",
15        temperature=0
16    )
17
18    agent = llm.bind_tools(
19        [email_tool],
20        tool_choice="any", # force using a tool
21        parallel_tool_calls=False
22    )
23
24    # Get user input
25    request = input("What email would you like to send? ")
26
27    # Get tool call from model
28    response = agent.invoke(request)
29
30    if response.tool_calls:
31        # Execute the tool
32        args = response.tool_calls[0]["args"]
33        result = email_tool.invoke(args)
34        print(f"Result: {result}")
35    else:
36        print("No email action needed.")
37
38if __name__ == "__main__":
39    main()

1#!/usr/bin/env python3
2from langchain.chat_models import init_chat_model
3from langchain.tools import tool
4
5@tool
6def email_tool(to: str, subject: str, content: str) -> str:
7    """Draft email and send."""
8    # Placeholder: we'd use an actual mailing service here
9    return f"Email sent to: {to} | Subject: {subject} | Content: {content}"
10
11def main():
12    # Initialize model
13    llm = init_chat_model(
14        "google_vertexai:gemini-2.0-flash",
15        temperature=0
16    )
17
18    agent = llm.bind_tools(
19        [email_tool],
20        tool_choice="any", # force using a tool
21        parallel_tool_calls=False
22    )
23
24    # Get user input
25    request = input("What email would you like to send? ")
26
27    # Get tool call from model
28    response = agent.invoke(request)
29
30    if response.tool_calls:
31        # Execute the tool
32        args = response.tool_calls[0]["args"]
33        result = email_tool.invoke(args)
34        print(f"Result: {result}")
35    else:
36        print("No email action needed.")
37
38if __name__ == "__main__":
39    main()

Usage: python email_agent.py then type "Send a meeting reminder to somebody@company.com"