Configuration guide for LangChain applications.
# OpenAI
export OPENAI_API_KEY="sk-your-key"
# Anthropic
export ANTHROPIC_API_KEY="sk-ant-key"
# Google
export GOOGLE_API_KEY="your-key"
export GOOGLE_CLOUD_PROJECT="your-project"
# Azure OpenAI
export AZURE_OPENAI_API_KEY="your-key"
export AZURE_OPENAI_ENDPOINT="https://your-endpoint.openai.azure.com/"
export AZURE_OPENAI_API_VERSION="2025-01-01-preview"
# AWS Bedrock
export AWS_ACCESS_KEY_ID="your-key"
export AWS_SECRET_ACCESS_KEY="your-secret"
export AWS_DEFAULT_REGION="us-east-1"
export LANGCHAIN_API_KEY="your-langsmith-key"
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_PROJECT="my-project"
export LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="gpt-4o",
temperature=0.7,
max_tokens=2000,
timeout=30,
max_retries=3
)
from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(
model="claude-sonnet-4-20250514",
temperature=0.7,
max_tokens=2000,
timeout=30
)
from langchain_google_genai import ChatGoogleGenerativeAI
llm = ChatGoogleGenerativeAI(
model="gemini-pro",
temperature=0.7,
max_output_tokens=2000
)
from langchain_ollama import ChatOllama
llm = ChatOllama(
model="llama3.1",
base_url="http://localhost:11434",
temperature=0.7
)
from langchain_openai import AzureChatOpenAI
llm = AzureChatOpenAI(
azure_endpoint="https://your-endpoint.openai.azure.com/",
azure_deployment="gpt-4o",
openai_api_version="2025-01-01-preview",
api_key="your-key"
)
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
persist_directory="./chroma_db",
embedding_function=embeddings,
collection_name="my_collection"
)
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(
texts=["document 1", "document 2"],
embedding=embeddings
)
# Save to disk
vectorstore.save_local("faiss_index")
# Load from disk
vectorstore = FAISS.load_local(
"faiss_index",
embeddings,
allow_dangerous_deserialization=True
)
from langchain_pinecone import PineconeVectorStore
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
vectorstore = PineconeVectorStore.from_existing_index(
index_name="my-index",
embedding=embeddings
)
from langchain.agents import create_agent
def get_weather(city: str) -> str:
"""Get weather for a city."""
return f"It's sunny in {city}"
agent = create_agent(
model="gpt-4o",
tools=[get_weather],
system_prompt="You are a helpful assistant"
)
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools import DuckDuckRunSearchTool
tools = [DuckDuckRunSearchTool()]
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}")
])
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools)
response = agent_executor.invoke({"input": "What's the weather in SF?"})
from langchain.tools import tool
@tool
def calculate(expression: str) -> str:
"""Evaluate a mathematical expression."""
try:
result = eval(expression)
return str(result)
except Exception as e:
return f"Error: {str(e)}"
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
prompt = ChatPromptTemplate.from_messages([
("system", "You are a translator"),
("human", "Translate to {language}: {text}")
])
llm = ChatOpenAI(model="gpt-4o")
chain = prompt | llm | StrOutputParser()
response = chain.invoke({"language": "Spanish", "text": "Hello!"})
from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer based on context:\n{context}"),
("human", "{question}")
])
retriever = vectorstore.as_retriever()
chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(
return_messages=True,
output_key="output"
)
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant"),
MessagesPlaceholder(variable_name="history"),
("human", "{input}")
])
from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(
llm=llm,
return_messages=True
)
from langchain_core.callbacks import StreamingStdOutCallbackHandler
llm = ChatOpenAI(
model="gpt-4o",
streaming=True,
callbacks=[StreamingStdOutCallbackHandler()]
)
from langchain_core.callbacks import BaseCallbackHandler
class MyCallbackHandler(BaseCallbackHandler):
def on_llm_start(self, serialized, prompts, **kwargs):
print(f"Starting LLM with {len(prompts)} prompts")
def on_llm_end(self, response, **kwargs):
print(f"LLM completed: {response}")
llm = ChatOpenAI(callbacks=[MyCallbackHandler()])
from langchain_core.retries import RetryPolicy
retry_policy = RetryPolicy(
max_retries=3,
retry_on_exceptions=[Exception],
retry_on_status_codes=[429, 503]
)
llm = ChatOpenAI(
model="gpt-4o",
timeout=30,
retry_policy=retry_policy
)
from langchain_core.rate_limiters import InMemoryRateLimiter
rate_limiter = InMemoryRateLimiter(
requests_per_second=10,
check_every_n_seconds=0.1
)
llm = ChatOpenAI(
model="gpt-4o",
rate_limiter=rate_limiter
)