Introduction to LangChain and AI Agents

LangChain has rapidly become a preferred framework for developers aiming to build sophisticated AI applications, with a particular focus on creating intelligent agents. These agents possess the capability to understand user intent, interact with external tools, and execute commands, making them powerful assets in various applications. This tutorial serves as a beginner's guide to constructing your very own AI agent using LangChain, demystifying the installation, setup, and operational procedures involved.

Step 1: Installation and Environment Setup

Before embarking on agent development, the initial step involves setting up your development environment. This begins with ensuring you have Python 3 and its package installer, Pip, readily available. If not, you can install them using your system's package manager. For Debian-based systems like Ubuntu, the commands are as follows:

sudo apt update

sudo apt install python3 python3-pip

Once Python and Pip are installed, you can proceed to install the LangChain library itself. This is achieved using Pip:

pip install langchain

To integrate with specific LLMs and tools, additional packages may be required. For this tutorial, which utilizes Google Gemini, you'll need to install the relevant integration:

pip install -qU "langchain[google-genai]"

Step 2: Integrating a Large Language Model (LLM)

The intelligence of your AI agent is powered by a Large Language Model (LLM). This tutorial uses Google Gemini. To enable communication with Gemini, you first need to set up your API key. It's recommended to store this key securely, for example, as an environment variable. If the environment variable is not set, the script will prompt you to enter it.

import getpass
import os

if not os.environ.get("GOOGLE_API_KEY"):
 os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter API key for Google Gemini: ")

With the API key configured, you can now initialize the chat model. This involves specifying the model name and the provider. For this tutorial, we use the "gemini-2.0-flash" model from Google GenAI:

from langchain.chat_models import init_chat_model

model = init_chat_model("gemini-2.0-flash", model_provider="google_genai")

To test the LLM integration, you can send a simple query. The `.invoke` method allows you to pass a string query directly to the model. For instance, asking about the start date of the French Revolution:

model.invoke("When did the French Revolution start?")

The output from the LLM will be displayed, confirming that the model is correctly set up and responsive. This step is crucial for verifying that your foundational AI component is operational before proceeding to agent construction.

Step 3: Setting Up and Integrating Tools

An AI agent becomes truly powerful when it can interact with the outside world or perform specific tasks. This is achieved through "tools." For this tutorial, we will integrate the File Management toolkit, which allows the agent to interact with the local file system. This includes capabilities like reading, writing, and listing files. To use this toolkit, you need to install the `langchain-community` package:

pip install -qU langchain-community

Next, import the necessary modules and define the tools you want your agent to have access to. In this case, we select "read_file", "write_file", and "list_directory" from the File Management toolkit.

from langchain_community.agent_toolkits import FileManagementToolkit

It is crucial to define a working directory for the File Management toolkit. This directory will be the scope within which the agent can operate. For safety and to avoid accidental modifications to important files, it is highly recommended to use a temporary directory, especially during development and testing. The following code sets up a temporary directory:

from tempfile import TemporaryDirectory

working_directory = TemporaryDirectory()

Now, instantiate the `FileManagementToolkit`, specifying the root directory and the selected tools. This object will then be used to get the actual tools that the agent can utilize:

tools = FileManagementToolkit(
 root_dir=str(working_directory.name),
 selected_tools=["read_file", "write_file", "list_directory"],
 ).get_tools()

These `tools` are now ready to be integrated with the LLM to form the AI agent.

Step 4: Building the AI Agent

With the LLM and tools configured, the next step is to construct the AI agent. This involves binding the LLM with the available tools, enabling the LLM to understand when and how to use them. For this, we use LangGraph, a framework developed by LangChain for building stateful applications and agents. First, ensure LangGraph is installed:

pip install -U langgraph

Now, you can create the agent executor. This process binds the LLM to the tools, preparing it to receive user input and decide on actions. The `create_react_agent` function from LangGraph is used here, taking the initialized LLM and the list of tools as arguments:

from langgraph.prebuilt import create_react_agent

agent_executor = create_react_agent(model, tools)

The `agent_executor` is now an instance of your AI agent, capable of processing natural language instructions and utilizing the file management tools.

Step 5: Running and Interacting with the AI Agent

The final stage is to run the AI agent and test its capabilities. You can interact with the agent by submitting messages through the `agent_executor.invoke` method. The input message should be a dictionary with a "role" (user) and "content" (the instruction).

Let's start by asking the agent to list the files in the current working directory. Since we used a temporary directory that has just been created, it should be empty:

input_message = {"role": "user", "content": "List files in the current working directory"}
response = agent_executor.invoke({"messages": [input_message]})

for message in response["messages"]:
 message.pretty_print()

As expected, the output indicates that no files were found in the directory. The agent successfully used the "list_directory" tool and reported the result.

Next, let's instruct the agent to create a file named "sample-file.txt":

input_message = {"role": "user", "content": "Create a file named sample-file.txt"}
response = agent_executor.invoke({"messages": [input_message]})

for message in response["messages"]:
 message.pretty_print()

The agent confirms the creation of the file. To verify, we can ask it to list the files again:

input_message = {"role": "user", "content": "Print the names of files in the working directory and their contents"}
response = agent_executor.invoke({"messages": [input_message]})

for message in response["messages"]:
 message.pretty_print()

The output now shows "sample-file.txt" in the directory. The agent has successfully created and identified the file, demonstrating its ability to perform file management tasks based on user commands.

Conclusion and Further Exploration

This tutorial has provided a foundational understanding of how to build an AI agent with LangChain. You have learned to install LangChain, integrate an LLM like Google Gemini, set up and utilize tools such as the File Management toolkit, and construct a functional agent using LangGraph. The agent was then tested with practical file operations. While this example covers basic file management, LangChain

Tag: agents

Harnessing the Power of JSON-based Agents: Integrating Ollama, LangChain, and Neo4j

Building Your First AI Agent with LangChain: A Beginner-Friendly Tutorial