LangChain

# Install core packages
pip install langchain
pip install langchain-core
pip install langchain-community

# Install specific integrations
pip install langchain-openai
pip install langchain-anthropic
pip install langchain-google-genai

# Install all dependencies
pip install langchain[all]

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

# OpenAI
llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
response = llm.invoke("Explain quantum computing")

# Anthropic
llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")

# Streaming output
for chunk in llm.stream("Write a poem"):
    print(chunk.content, end="")

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a {role} expert."),
    ("human", "Please explain {topic}."),
])

chain = prompt | llm
response = chain.invoke({"role": "AI", "topic": "deep learning"})

from langchain_core.output_parsers import StrOutputParser

# LCEL chain
chain = prompt | llm | StrOutputParser()
result = chain.invoke({"role": "AI", "topic": "RAG"})

# Complex chain
from langchain_core.runnables import RunnablePassthrough

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

from langchain.agents import create_tool_calling_agent, AgentExecutor

tools = [search_tool, calculator_tool]
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

result = executor.invoke({"input": "What is the size of the AI market in 2024?"})

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

chain = prompt | llm | StrOutputParser()
# Use memory in the chain
chain_with_memory = (
    RunnablePassthrough.assign(
        history=lambda x: memory.load_memory_variables({})["chat_history"]
    )
    | prompt
    | llm
)

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
docs = retriever.invoke("query question")

from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Load and split documents
loader = WebBaseLoader("https://example.com")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
splits = splitter.split_documents(docs)

# Create vector store
vectorstore = Chroma.from_documents(splits, embeddings)
retriever = vectorstore.as_retriever()

# RAG chain
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
)

from langchain_core.tools import tool

@tool
def search_web(query: str) -> str:
    """Search the web for information."""
    # Implement search logic
    return search_results

@tool
def calculate(expression: str) -> str:
    """Calculate a math expression."""
    return str(eval(expression))

tools = [search_web, calculate]

from langchain_core.callbacks import BaseCallbackHandler

class MyHandler(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM start: {serialized}")
    
    def on_llm_end(self, response, **kwargs):
        print(f"LLM end: {response}")

chain.invoke("question", config={"callbacks": [MyHandler()]})

# Deploy with LangServe
from langserve import add_routes
from fastapi import FastAPI

app = FastAPI()
add_routes(app, chain, path="/chat")

# Run: uvicorn server:app --reload
# Access: http://localhost:8000/chat/playground

# .env
OPENAI_API_KEY=your-key
ANTHROPIC_API_KEY=your-key
LANGCHAIN_API_KEY=your-key      # for LangSmith tracing
LANGCHAIN_TRACING_V2=true

# Python: pick a model
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

# LCEL chain
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

chain = prompt | llm | StrOutputParser()

# Vector store
from langchain_chroma import Chroma
vectorstore = Chroma(embedding_function=embeddings,
                     persist_directory="./chroma_db")

Q: How do I switch models?
A: Change the model class (ChatOpenAI -> ChatAnthropic) and the env var;
   LCEL chains work unchanged.

Q: How do I cut costs?
A: Use gpt-4o-mini for simple tasks, cache responses, and trim context
   before passing to the LLM.

Q: Which vector store should I use?
A: Chroma for local dev, Pinecone/Weaviate for production, FAISS for
   in-memory experiments.

Q: LangSmith vs LangServe?
A: LangSmith monitors and traces LLM calls; LangServe deploys chains as
   REST APIs. They are complementary.

Q: What is LCEL?
A: LangChain Expression Language—compose chains with the | pipe operator,
   getting streaming, async, and batch for free.