pip install langchain langchain-openai langchain-community
pip install python-dotenv  # for environment variables

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
 
llm = ChatOpenAI(model="gpt-4o", temperature=0)
 
response = llm.invoke([HumanMessage(content="What is LangChain?")])
print(response.content)

from langchain_core.prompts import ChatPromptTemplate
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant that summarizes articles."),
    ("human", "Summarize the following text:\n\n{text}"),
])
 
chain = prompt | llm
result = chain.invoke({"text": "LangChain is an open-source framework..."})
print(result.content)

pip install openai

import os
from openai import OpenAI
 
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Explain async/await in Python."},
    ],
    temperature=0.7,
    max_tokens=500,
)
 
print(response.choices[0].message.content)

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a poem about code."}],
    stream=True,
)
 
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

response = client.images.generate(
    model="dall-e-3",
    prompt="A futuristic city skyline at sunset, digital art",
    size="1024x1024",
    quality="standard",
    n=1,
)
 
print(response.data[0].url)

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate
 
# 1. Create documents
docs = [
    Document(page_content="LangChain is a framework for building LLM apps."),
    Document(page_content="RAG combines retrieval with generation for accuracy."),
    Document(page_content="Vector databases store numerical embeddings of text."),
]
 
# 2. Create vector store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = FAISS.from_documents(docs, embeddings)
retriever = vector_store.as_retriever(search_kwargs={"k": 2})
 
# 3. Create RAG chain
llm = ChatOpenAI(model="gpt-4o")
system_prompt = """Use the provided context to answer the question.
If you don't know, say so. Be concise.
 
Context: {context}"""
 
prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "{input}"),
])
 
question_answer_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(retriever, question_answer_chain)
 
# 4. Query
result = rag_chain.invoke({"input": "What is RAG?"})
print(result["answer"])

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import tool
 
# 1. Define tools
@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # In production, call a real weather API
    return f"The weather in {city} is 22°C and sunny."
 
@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"Error: {e}"
 
tools = [get_weather, calculate]
 
# 2. Create the agent
llm = ChatOpenAI(model="gpt-4o")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with access to tools."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])
 
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
# 3. Run the agent
result = agent_executor.invoke({"input": "What's the weather in Kathmandu?"})
print(result["output"])

from openai import OpenAI
 
client = OpenAI()
 
def embed(text: str) -> list[float]:
    response = client.embeddings.create(
        input=text,
        model="text-embedding-3-small"
    )
    return response.data[0].embedding
 
# Embed a single text
vector = embed("What is machine learning?")
print(f"Dimensions: {len(vector)}")  # 1536
 
# Batch embed multiple texts
texts = ["Hello world", "Machine learning is fun", "Python is great"]
response = client.embeddings.create(input=texts, model="text-embedding-3-small")
vectors = [item.embedding for item in response.data]

import numpy as np
 
def cosine_similarity(a: list, b: list) -> float:
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
 
query = embed("What is AI?")
doc1  = embed("Artificial intelligence is the simulation of human intelligence.")
doc2  = embed("The stock market closed higher today.")
 
print(cosine_similarity(query, doc1))  # ~0.85 (high similarity)
print(cosine_similarity(query, doc2))  # ~0.12 (low similarity)

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
 
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 
# Create index
db = FAISS.from_texts(
    ["LangChain is a framework", "FAISS is fast", "RAG improves accuracy"],
    embeddings
)
 
# Similarity search
results = db.similarity_search("What is FAISS?", k=2)
for doc in results:
    print(doc.page_content)
 
# Save & load
db.save_local("faiss_index")
db = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
 
embeddings = OpenAIEmbeddings()
 
# Create persistent collection
db = Chroma(
    collection_name="my_docs",
    embedding_function=embeddings,
    persist_directory="./chroma_db"
)
 
db.add_texts(["Document 1 content", "Document 2 content"])
 
# Query
results = db.similarity_search("search query", k=3)

from pinecone import Pinecone
from langchain_pinecone import PineconeVectorStore
from langchain_openai import OpenAIEmbeddings
 
pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")
index = pc.Index("my-index")
 
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = PineconeVectorStore(index=index, embedding=embeddings)
 
# Add documents
vector_store.add_texts(["Your document text here"])
 
# Search
results = vector_store.similarity_search("query", k=5)

# Pipe operator chains components together
chain = prompt | llm | output_parser
 
# With retry and fallbacks
chain = (prompt | llm.with_retry(stop_after_attempt=3)).with_fallbacks([backup_llm])
 
# Parallel execution
from langchain_core.runnables import RunnableParallel
chain = RunnableParallel(
    summary=summary_chain,
    keywords=keyword_chain,
)

# .env file
OPENAI_API_KEY=sk-...
LANGCHAIN_API_KEY=ls__...    # for LangSmith tracing
LANGCHAIN_TRACING_V2=true
LANGCHAIN_PROJECT=my-project

from dotenv import load_dotenv
load_dotenv()  # loads .env automatically