How to Set Up LangChain: A Practical Guide for Enterprise AI Teams

# Create a virtual environment (recommended)
python -m venv langchain-env
source langchain-env/bin/activate  # Linux/macOS
# OR
langchain-env\Scripts\activate     # Windows

# Install LangChain (core package)
pip install langchain==0.2.0

# Install optional dependencies (e.g., for OpenAI, ChromaDB)
pip install langchain-openai chromadb tiktoken

Successfully installed langchain-0.2.0 ...

# Initialize a Node.js project (if starting fresh)
npm init -y

# Install LangChain
npm install [email protected]

# Install optional dependencies (e.g., for OpenAI)
npm install @langchain/openai

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Initialize the LLM (requires OPENAI_API_KEY in environment)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# Define a prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{input}")
])

# Create the chain: prompt → LLM → output parser
chain = prompt | llm | StrOutputParser()

# Run the chain
response = chain.invoke({"input": "Explain LangChain in one sentence."})
print(response)

export OPENAI_API_KEY="your-api-key"  # Linux/macOS
# OR
set OPENAI_API_KEY="your-api-key"     # Windows
python first_chain.py

LangChain is a framework for building applications with large language models by chaining together modular components like prompts, LLMs, and tools.

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Load a PDF (e.g., a product manual)
loader = PyPDFLoader("example.pdf")
pages = loader.load()

# Split into chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
docs = text_splitter.split_documents(pages)

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# Embed and store documents
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings(),
    persist_directory="./chroma_db"
)

from langchain_core.runnables import RunnablePassthrough

# Retrieve relevant documents
retriever = vectorstore.as_retriever()

# Define the RAG prompt
rag_prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer the question based on the following context:\n{context}"),
    ("user", "{question}")
])

# Combine retrieval and generation
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# Ask a question
response = rag_chain.invoke("What is the warranty period?")
print(response)

The warranty period for this product is 2 years from the date of purchase, as stated on page 5 of the manual.

from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

# Wikipedia tool
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())

# Custom tool (e.g., calculator)
from langchain_core.tools import tool

@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers."""
    return a * b

tools = [wikipedia, multiply]

from langchain_openai import ChatOpenAI
from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent

# Pull a pre-built prompt
prompt = hub.pull("hwchase17/openai-tools-agent")

# Initialize the agent
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run the agent
response = agent_executor.invoke({
    "input": "What is the population of France in 2026? Multiply it by 2."
})
print(response["output"])

The agent will use the Wikipedia tool to look up the population of France and then apply the multiply tool to the result.

from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# Initialize chat history
history = InMemoryChatMessageHistory()

# Add messages
history.add_user_message("What is LangChain?")
history.add_ai_message("LangChain is a framework for building LLM applications.")

# Create a chain with history
chain = prompt | llm | StrOutputParser()
chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

# Run with history
response = chain_with_history.invoke(
    {"input": "How do I get started?"},
    config={"configurable": {"session_id": "abc123"}}
)
print(response)

To get started with LangChain, install it using pip and follow the quickstart guide at python.langchain.com. Would you like a code example?

from langchain_community.chat_message_histories import SQLChatMessageHistory

# Store history in SQLite
history = SQLChatMessageHistory(
    session_id="abc123",
    connection_string="sqlite:///chat_history.db"
)

# Use in a chain (same as above)
chain_with_history = RunnableWithMessageHistory(...)

from langchain_core.tracers import LangChainTracer

tracer = LangChainTracer(
    project_name="my-project",
    api_key="your-langsmith-api-key"
)

# Add to your chain
chain = prompt | llm | StrOutputParser()
chain_with_tracing = chain.with_config({"callbacks": [tracer]})

# Run the chain
response = chain_with_tracing.invoke({"input": "Debug me!"})
print(response)

Run ID: 123e4567-e89b-12d3-a456-426614174000
Status: Success
Latency: 1.2s
Steps:
  1. PromptTemplate: "You are a helpful assistant. Answer: {input}"
  2. ChatOpenAI: gpt-4o-mini (input_tokens=10, output_tokens=25)
  3. StrOutputParser: "Debugging is fun!"