top of page

Building AI Agents from Scratch with LangChain: A Step-by-Step Guide

Writer's picture: AmanAman

Langchain enabling seamless agent implementation for enhanced retail experiences.
Langchain enabling seamless agent implementation for enhanced retail experiences.


Introduction

Artificial Intelligence (AI) agents are transforming how businesses automate complex workflows, making them more adaptive and intelligent. These agents go beyond static rule-based systems, leveraging large language models (LLMs) and tool integrations to make decisions, interact with external systems, and continuously improve.


In this guide, we will build an AI-powered E-commerce Shopping Assistant using LangChain, a powerful framework for developing LLM-based applications. Our agent will:

  • Understand user preferences and queries.

  • Search for products across multiple platforms.

  • Compare prices and provide recommendations.

  • Assist in making dynamic, personalized shopping decisions.


Let’s dive into how to design, build, and deploy AI agents using LangChain from scratch.


Understanding LangChain: The Basics


Before we start building, let's understand some core components of LangChain:


  • LLMs (Large Language Models)

LLMs, like GPT-4 and Claude, serve as the brain of AI agents. They process inputs, generate responses, and interact with data sources. LangChain simplifies their integration into applications.


  • Memory and Context

Unlike basic chatbots, AI agents need memory to retain past interactions and improve responses. LangChain provides different types of memory to store and retrieve past user queries.


  • Tools and External APIs

LangChain allows AI agents to interact with APIs, databases, and real-world tools to fetch real-time data, perform computations, and enhance decision-making.


  • Agents and Chains

    • Chains: Sequential processing of user queries through pre-defined steps.

    • Agents: More dynamic, deciding their next actions based on context and available tools.



Now, let’s apply these concepts to build our E-commerce AI Assistant.



 


Step 1: Setting Up the Environment


First, install the required dependencies:


In bash terminal:

pip install langchain openai chromadb beautifulsoup4 requests

Configure OpenAI API Key:

Get an API key from OpenAI and set it in your environment variables.


import os
from langchain.llms import OpenAI

os.environ["OPENAI_API_KEY"] = "your-api-key-here"
llm = OpenAI(model="gpt-4")


 


Step 2: Building the AI Agent Core

Our assistant should remember user preferences, fetch product data, and provide insights.


Initialize Memory


from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(memory_key="chat_history")

Set Up the LLM


from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(temperature=0.7, model_name="gpt-4")

Define Prompt for Context-Aware Responses


from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["chat_history", "user_query"],
    template="""
    You are an AI shopping assistant. Keep track of user preferences.
    Use past conversations: {chat_history}.
    User's query: {user_query}
    """
)

 


Step 3: Integrating External Tools

We’ll integrate a price comparison API and a web scraper for real-time product fetching.


Web Scraping for E-commerce Data


import requests
from bs4 import BeautifulSoup

def get_amazon_price(product_name):
    url = f"https://www.amazon.com/s?k={product_name.replace(' ', '+')}"
    headers = {"User-Agent": "Mozilla/5.0"}
    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.text, "html.parser")

    product = soup.find("span", class_="a-price-whole")
    return product.text if product else "Price not found"


 


Step 4: Designing the Agent’s Workflow

Now, let’s build an AI agent that interacts dynamically with users and fetches real-time product data.


from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool

# Define Tools
price_tool = Tool(
    name="PriceChecker",
    func=get_amazon_price,
    description="Fetches Amazon product prices."
)

# Initialize Agent
agent = initialize_agent(
    llm=llm,
    tools=[price_tool],
    memory=memory,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

Testing the Agent


query = "Find the best price for iPhone 15 Pro."
response = agent.run(query)
print(response)

Now, the agent searches for real-time product prices and responds dynamically!




 


Step 5: Deploying the AI Agent

You can deploy the AI shopping assistant as a chatbot via WhatsApp, Telegram, or a Web App.


Option 1: FastAPI for Web Deployment


from fastapi import FastAPI

app = FastAPI()

@app.get("/ask")
def ask(query: str):
    return {"response": agent.run(query)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Now, your AI assistant is accessible via API and can be used in various applications!



 


Potential Enhancements

  • Multi-Agent Collaboration: Different agents handling payments, logistics, etc.

  • Voice Interaction: Use speech-to-text APIs for verbal shopping assistance.

  • Blockchain Verification: Verify product authenticity and transaction security.



Conclusion


  • Built an AI shopping assistant using LangChain.

  • Integrated memory, real-time data, and API tools.

  • Developed a dynamic, intelligent AI agent for e-commerce.


What’s Next?

AI agents are revolutionizing industries, and LangChain makes building them easy.

This is just the beginning—multi-agent systems and blockchain integration will take automation to the next level!

Comments


bottom of page