Skip to main content
This quickstart shows you how to create a fully functional AI agent in just a few minutes.
Using an AI coding assistant?
  • Install the LangChain Docs MCP server to give your agent access to up-to-date LangChain documentation and examples.
  • Install LangChain Skills to improve your agent’s performance on LangChain ecosystem tasks.

​
Install dependencies

Install the following packages to follow along: 
uv init
uv add langchain deepagents
uv sync
# Requires Python 3.10+

​
Set up API keys

Get an API key from any supported model provider (for example, OpenAI or Google Gemini). Set the API keys, for example: 
export OPENAI_API_KEY="your-api-key"

​
Build a basic agent

Start by creating a simple agent that can answer questions and call tools. The agent in this example uses the chosen language model, a basic weather function as a tool, and a simple prompt to guide its behavior: 
from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

agent = create_agent(
    model="openai:gpt-5.2",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]}
)
print(result["messages"][-1].content)
When you run the code and prompt the agent to tell you about the weather in San Francisco, the agent uses that input and its available context. The agent understands that you are asking about the weather for the city San Francisco and therefore calls the weather tool with the provided city name. This is how you get the response "It's always sunny in San Francisco!".
You can use any supported model by changing the model name in the code and setting up the appropriate API key.

​
Build a real-world agent

In the following example you will build a research agent that can answer questions about text files. Along the way you will explore the following concepts:
  1. Detailed system prompts for better agent behavior
  2. Create tools that integrate with external data
  3. Model configuration for consistent responses
  4. Conversational memory for chat-like interactions
  5. Deep Agents for built-in features
  6. Testing your agent
1

Define the system prompt

The system prompt defines your agent’s role and behavior. Keep it specific and actionable:
SYSTEM_PROMPT = """You are a literary data assistant.

## Capabilities

- `fetch_text_from_url`: loads document text from a URL into the conversation.
Do not guess line counts or positions—ground them in tool results from the saved file."""
2

Create tools

Tools let a model interact with external systems by calling functions you define. Tools can depend on runtime context and also interact with agent memory.This example uses a tool to load a document from a given URL:
import urllib.error
import urllib.request

from langchain.tools import tool


@tool
def fetch_text_from_url(url: str) -> str:
    """Fetch the document from a URL.
    """
    req = urllib.request.Request(
        url,
        headers={"User-Agent": "Mozilla/5.0 (compatible; quickstart-research/1.0)"},
    )
    try:
        with urllib.request.urlopen(req, timeout=120) as resp:
            raw = resp.read()
    except urllib.error.URLError as e:
        return f"Fetch failed: {e}"
    text = raw.decode("utf-8", errors="replace")
    return text
Tools should be well-documented: their name, description, and argument names become part of the model’s prompt. LangChain’s @tool decorator adds metadata and enables runtime injection with the ToolRuntime parameter. Learn more in the tools guide.
3

Configure your model

Set up your language model with the right parameters for your use case. For example:
from langchain.chat_models import init_chat_model

model = init_chat_model(
    "openai:gpt-5.2",
    temperature=0.5,
    timeout=300,
    max_tokens=25000,
)
Depending on the model and provider chosen, initialization parameters may vary; refer to their reference pages for details.
4

Add memory

Add memory to your agent to maintain state across interactions. This allows the agent to remember previous conversations and context.
from langgraph.checkpoint.memory import InMemorySaver

checkpointer = InMemorySaver()
In production, use a persistent checkpointer that saves message history to a database. See Add and manage memory for more details.
5

Create and run the agent

Now assemble your agent with all the components and run it.There are two different frameworks for creating agents: LangChain agents and deep agents. Both LangChain and deep agents provide you with fine-grained control over tools, memory, and more. The main difference between both is that deep agents come with a range of commonly useful capabilities already built in, such as planning, file system tools, and subagents.Use deep agents when you want maximum capability with minimal setup; choose LangChain agents when you need fine-grained control.
Since the code invokes the model with the entire text from The Great Gatsby, it uses a large amount of tokens.You can view example output in the next step.
Let’s try both:
from langchain.agents import create_agent
from deepagents import create_deep_agent

agent = create_agent(
    model=model,
    tools=[fetch_text_from_url],
    system_prompt=SYSTEM_PROMPT,
    checkpointer=checkpointer,
)

deep_agent = create_deep_agent(
    model=model,
    tools=[fetch_text_from_url],
    system_prompt=SYSTEM_PROMPT,
    checkpointer=checkpointer,
)

content = f"""Project Gutenberg hosts a full plain-text copy of F. Scott Fitzgerald's The Great Gatsby.
URL: https://www.gutenberg.org/files/64317/64317-0.txt

Answer as much as you can:

1) How many lines in the complete Gutenberg file contain the substring `Gatsby` (count lines, not occurrences within a line, each line ends with a line break).
2) The 1-based line number of the first line in the file that contains `Daisy`.
3) A two-sentence neutral synopsis.

Do your best on (1) and (2). If at any point you realize you cannot **verify** an exact answer with
your available tools and reasoning, do not fabricate numbers: use `null` for that field and spell out
the limitation in `how_you_computed_counts`. If you encounter any errors please report what the error was and what the error message was."""

agent_result = agent.invoke(
    {"messages": [{"role": "user", "content": content}]},
    config={"configurable": {"thread_id": "great-gatsby-lc"}},
)
deep_agent_result = deep_agent.invoke(
    {"messages": [{"role": "user", "content": content}]},
    config={"configurable": {"thread_id": "great-gatsby-da"}},
)
print(agent_result["messages"][-1].content)
print("\n")
print(deep_agent_result["messages"][-1].content)
6

Review the results

The results will differ based on the model and the execution.
**1) Number of lines containing `Gatsby`:** `null`

**2) First line containing `Daisy`:** `null`

**3) Synopsis:**
The Great Gatsby follows the mysterious millionaire Jay Gatsby and his obsession with reuniting with his former lover, Daisy Buchanan, as narrated by his neighbor Nick Carraway. Set against the backdrop of the Roaring Twenties on Long Island, the novel explores themes of wealth, class, and the elusive nature of the American Dream.

**how_you_computed_counts:**
I successfully fetched the full text of the eBook using the `fetch_text_from_url` tool. However, because I do not have access to a code execution environment (like Python) or text-processing tools (like `grep`), I cannot deterministically split the text by line breaks, iterate through the thousands of lines, and verify the exact line numbers or match counts. LLMs cannot reliably perform exact line-counting or indexing over massive texts within their context window without external computational tools. As instructed, rather than fabricating or guessing a number, I have output `null` for the exact counts and positions.
If you look at the output on both tabs, you notice that the LangChain agent provided answers but they are estimates. The agent lacks the tools to answer this question. You may also get errors that the prompt is too long.The deep agent, on the other hand can:
  1. Plans its approach using the built-in write_todos tool to break down the research task.
  2. Loads the file by calling the fetch_text_from_url tool to gather information.
  3. Manages context by using file system tools (grep and read_file).
  4. Spawns subagents as needed to delegate complex subtasks to specialized subagents.
For LangChain agents, you must implement more capabilities to get a similar level of service and can customize them along the way as needed.

​
Trace agent calls

Most interesting applications you build with LangChain make many calls to LLMs. As these applications get more complex, it becomes important to be able to inspect what exactly is going on inside your agent. The best way to do this is with LangSmith. Sign up for a LangSmith account and set these to start logging traces: 
export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="..."
Once set, run your script again and then inspect what happened during your agent calls on LangSmith .
To learn more about tracing your agent with LangSmith, see the LangSmith documentation.

​
Next steps

You now have agents that can:
  • Understand context and remember conversations
  • Use tools intelligently
  • Provide structured responses in a consistent format
  • Handle user-specific information through context
  • Maintain conversation state across interactions
  • Plan, research, and synthesize (deep agents only)
Continue with:
Edit this page on GitHub or file an issue.
Connect these docs to Claude, VSCode, and more via MCP for real-time answers.