LangChain Free code examples in Python and JavaScript

The provider is an extra, not a separate top-level package: langchain[openai] rather than langchain plus langchain-openai in the common case.

pip install "langchain[openai]" langgraph

export OPENAI_API_KEY="sk-your-key"   # macOS / Linux
setx OPENAI_API_KEY "sk-your-key"     # Windows, then open a new shell

create_agent from langchain.agents. A plain function is a tool — the docstring is the description the model reads, and the type hints are the schema.

from langchain.agents import create_agent

def get_stock(code: str) -> str:
    """Get the current stock level for a single product code."""
    return f"{code}: 42 units"

agent = create_agent(
    model="gpt-5.4-mini",
    tools=[get_stock],
    system_prompt="You are a concise warehouse assistant.",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "How many X-17 do we have?"}]}
)

print(result["messages"][-1].content_blocks)

stream() with mode 'updates' shows each node as it finishes, which is how you find out the agent called the wrong tool rather than staring at a slow final answer.

for chunk in agent.stream(
    {"messages": [{"role": "user", "content": "How many X-17 do we have?"}]},
    stream_mode="updates",
):
    for node, update in chunk.items():
        # node is "model" or "tools" — watching this is how you debug
        # an agent that answers confidently without calling anything.
        print(node, update)

A GRAPH IS THE HONEST SHAPE OF A REAL AGENT. Branches, retries and human approval are edges and nodes; expressed as prompt instructions they are a state machine you cannot see, test or resume.

from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class Review(TypedDict):
    code: str
    findings: list[str]
    approved: bool

def analyse(state: Review) -> Review:
    return {**state, "findings": ["unbounded loop at line 42"]}

def needs_human(state: Review) -> str:
    # A real edge, not a sentence in a prompt hoping to be obeyed.
    return "approve" if state["findings"] else END

def approve(state: Review) -> Review:
    return {**state, "approved": True}

builder = StateGraph(Review)
builder.add_node("analyse", analyse)
builder.add_node("approve", approve)
builder.add_edge(START, "analyse")
builder.add_conditional_edges("analyse", needs_human)
builder.add_edge("approve", END)

graph = builder.compile()

A checkpointer is what makes the graph durable. interrupt_before stops at a node, the state is persisted against a thread id, and a later process resumes it — which is the whole argument for a graph over a loop.

from langgraph.checkpoint.memory import InMemorySaver

# In production this is Postgres or Redis; the interface is the same.
graph = builder.compile(
    checkpointer=InMemorySaver(),
    interrupt_before=["approve"],
)

config = {"configurable": {"thread_id": "review-118"}}

graph.invoke({"code": source, "findings": [], "approved": False}, config)

# ... minutes or days later, in a different process ...
state = graph.get_state(config)
print("waiting at:", state.next)

# Passing None means "carry on from where you stopped".
graph.invoke(None, config)