Vithor Varela's Blog

Exploring Generative AI with LangChain: A Comprehensive Guide with Python Examples

Vithor Varela's photo
Vithor Varela
·

4 min read

Generative AI has revolutionized the way we interact with technology by enabling systems to generate human-like text, create images, and solve complex problems. One of the most exciting libraries facilitating generative AI applications in Python is LangChain. LangChain simplifies the development of applications powered by large language models (LLMs) like OpenAI's GPT and others. In this blog post, we’ll explore what LangChain is, its benefits, and how to use it with examples of Python code.

What is LangChain?

LangChain is a Python library designed for building applications using LLMs. It offers robust features like chaining multiple calls to LLMs, integrating external data sources, and managing complex workflows. LangChain is ideal for use cases such as question answering, document summarization, chatbots, and custom AI tools.

Why Use LangChain?

  • Chaining Capabilities: Combine multiple calls to an LLM to build complex workflows.

  • Integration with External Data: Enhance LLM capabilities by integrating APIs, databases, and custom logic.

  • Modularity: Easily customize and extend functionality.

  • Community Support: A growing community with comprehensive documentation and examples.

Key Concepts in LangChain

Before diving into examples, let’s cover some fundamental concepts:

  1. Chains: A sequence of LLM calls combined to accomplish a specific task.

  2. Prompts: Templates for generating consistent and structured responses from the LLM.

  3. Memory: Persistent storage that allows the model to remember previous interactions.

  4. Agents: Tools for decision-making and task execution in more complex scenarios.

Setting Up LangChain

To get started, install the LangChain library and an LLM library (like OpenAI or Hugging Face). You’ll also need an API key for the LLM you intend to use.

pip install langchain openai

Set your OpenAI API key as an environment variable or in your script:

import os
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

Example 1: Simple Question-Answering Chain

Let’s start with a simple example where the model answers a question based on user input.

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Initialize the LLM
llm = OpenAI(model="text-davinci-003", temperature=0.7)

# Define a prompt template
prompt = PromptTemplate(
    input_variables=["question"],
    template="You are a helpful assistant. Answer this question: {question}"
)

# Create a chain
qa_chain = LLMChain(llm=llm, prompt=prompt)

# Run the chain
question = "What is the capital of France?"
response = qa_chain.run(question)
print(response)

Output:

Paris

Example 2: Building a Conversational Agent with Memory

LangChain supports conversational memory, enabling the model to recall past interactions.

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

# Initialize memory and the conversation chain
memory = ConversationBufferMemory()
conversation = ConversationChain(llm=llm, memory=memory)

# Simulate a conversation
print(conversation.run("Hi, who won the 2022 FIFA World Cup?"))
print(conversation.run("Can you tell me more about their performance?"))

Output:

Hi, who won the 2022 FIFA World Cup?
> Argentina won the 2022 FIFA World Cup.
Can you tell me more about their performance?
> Argentina showcased incredible skill and teamwork, winning in a dramatic final against France.

Example 3: Using LangChain Agents

Agents allow LangChain to interact with tools like APIs or databases dynamically. For example, we can create an agent that calculates mathematical expressions and answers general knowledge questions.

from langchain.agents import initialize_agent, Tool
from langchain.tools import tool
from langchain.llms import OpenAI

# Define a custom tool
@tool
def calculator(query: str) -> str:
    """Perform basic calculations"""
    try:
        result = eval(query)
        return str(result)
    except Exception as e:
        return f"Error: {e}"

# Initialize an agent with tools
tools = [Tool(name="Calculator", func=calculator)]
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)

# Run the agent
query = "What is 25 + 67 and who wrote Hamlet?"
response = agent.run(query)
print(response)

Output:

25 + 67 = 92. Hamlet was written by William Shakespeare.

Example 4: Document Summarization

LangChain can summarize large documents using an LLM.

from langchain.text_splitter import CharacterTextSplitter
from langchain.chains.summarize import load_summarize_chain

# Load a large document
document = """
Artificial Intelligence (AI) is a branch of computer science focused on building machines capable of performing tasks that typically require human intelligence. Examples include natural language processing, vision systems, and decision-making frameworks.
"""

# Split the document into manageable chunks
text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=0)
texts = text_splitter.split_text(document)

# Summarize the document
summarize_chain = load_summarize_chain(llm)
summary = summarize_chain.run(texts)
print(summary)

Output:

AI involves creating systems that mimic human intelligence, including NLP, vision, and decision-making.

Conclusion

LangChain offers a powerful and flexible way to build generative AI applications in Python. With its modular design and robust support for LLMs, LangChain simplifies complex workflows, enabling developers to focus on building innovative solutions. Whether you're creating a chatbot, summarizing documents, or integrating external tools, LangChain provides all the tools you need to succeed.

Ready to build your next generative AI application? Dive into the LangChain documentation and start experimenting today!

langchaingenerative aiPython