DEV Community

Cover image for How to Build AI Agents with LangChain
Bernard K
Bernard K

Posted on

How to Build AI Agents with LangChain

#ai #llm #machinelearning #python

Introduction to LangChain

LangChain simplifies building AI agents by providing a framework to connect language models with external data and APIs. It leverages the power of large language models to create interactive agents capable of complex tasks. This guide will walk you through setting up LangChain, creating your first AI agent, and deploying it effectively.

Installing LangChain and Dependencies

To get started, you'll need Python 3.8 or later. First, ensure you have pip installed. Then, use the following command to install LangChain and its dependencies:

pip install langchain
Enter fullscreen mode Exit fullscreen mode

Avoid specifying exact versions to ensure compatibility with the latest features. If you encounter issues with pip, ensure it's updated:

pip install --upgrade pip
Enter fullscreen mode Exit fullscreen mode

Setting Up Your Development Environment

Set up your environment by configuring your API keys securely. Store your OpenAI API key in an environment variable. For Linux/macOS, add this to your .bashrc or .zshrc:

export OPENAI_API_KEY='your-openai-api-key'
Enter fullscreen mode Exit fullscreen mode

Reload your shell configuration:

source ~/.bashrc
# or
source ~/.zshrc
Enter fullscreen mode Exit fullscreen mode

On Windows, use the set command in Command Prompt or PowerShell:

set OPENAI_API_KEY='your-openai-api-key'
Enter fullscreen mode Exit fullscreen mode

Creating Your First AI Agent

Let's create a simple AI agent using LangChain. Open a new Python file and add the following code:

import os
from langchain import ChatOpenAI
from langchain.prompts import ChatPromptTemplate  
from langchain.schema.output_parser import StrOutputParser

llm = ChatOpenAI(
    model="gpt-4",
    openai_api_key=os.getenv("OPENAI_API_KEY")
)

prompt = ChatPromptTemplate.from_template("Tell me about {topic}")
chain = prompt.compose(llm).compose(StrOutputParser())

result = chain.invoke({"topic": "AI"})
print(result)
Enter fullscreen mode Exit fullscreen mode

This code sets up a basic agent that responds to queries about a given topic. The compose method is used to create the chain, and StrOutputParser() extracts the response as a string.

Integrating External APIs and Data Sources

LangChain can integrate with various APIs. To do this, you'll typically need to create a custom chain component that interacts with the API. For detailed guidance, refer to the official docs: LangChain API Integration.

Testing and Debugging Your AI Agent

Testing is crucial. Use Python's built-in unittest module to create test cases for your agent. Here's a simple test example:

import unittest

class TestAIChain(unittest.TestCase):
    def test_response(self):
        result = chain.invoke({"topic": "AI"})
        self.assertIn("AI", result)

if __name__ == '__main__':
    unittest.main()
Enter fullscreen mode Exit fullscreen mode

Common errors include KeyError for missing environment variables. Ensure your API key is correctly set. If you see ModuleNotFoundError, verify your installation and Python path.

Deploying Your AI Agent

Deploy your agent using platforms like Heroku, AWS, or Docker. For Docker, create a Dockerfile:

FROM python:3.8-slim

WORKDIR /app
COPY . /app

RUN pip install langchain

CMD ["python", "your_script.py"]
Enter fullscreen mode Exit fullscreen mode

Build and run your Docker container:

docker build -t ai-agent .
docker run -e OPENAI_API_KEY='your-openai-api-key' ai-agent
Enter fullscreen mode Exit fullscreen mode

Best Practices and Tips for Using LangChain

  • Always use environment variables for sensitive data like API keys.
  • Regularly update your dependencies to leverage new features.
  • Use version control (e.g., Git) to manage code changes effectively.
  • Write comprehensive tests to ensure your agent behaves as expected.

References

Top comments (0)