Ananya S

Posted on Mar 2

🧠 Your LLM Isn’t an Agent — Until It Has Tools, Memory, and Structure (LangChain Deep Dive)

#ai #beginners #langchain #agents

Most “AI apps” today are just:

Prompt → LLM → Text Response

That’s not an agent.

That’s autocomplete with branding.

A real AI agent can:

🛠 Use tools
🧠 Remember context
📦 Return structured outputs
🔁 Reason across multiple steps

With modern LangChain, building this is surprisingly clean.

Let’s build one properly.

🚀 The Architecture of a Real Agent

A production-ready AI agent has four core components:

Model – the brain
Tools – capabilities
Structured outputs – reliability and formatting
Memory – continuity

If you’re missing one of these, you’re not building a system — you’re running a demo.

1️⃣ The Brain: Modern Agent Setup

We start with create_agent() — the current way to build agents in LangChain.

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

Low temperature = more deterministic reasoning.

Now let’s give it capabilities.

2️⃣ Tools: Giving the Agent Superpowers

Tools are just Python functions with clear docstrings.
The docstring matters — it’s how the model decides when to use the tool.

from langchain.tools import tool

@tool
def calculate_revenue(price: float, quantity: int) -> float:
    """Calculate total revenue given price per unit and quantity sold."""
    return price * quantity


@tool
def get_exchange_rate(currency: str) -> float:
    """Get the USD exchange rate for a given currency code."""
    rates = {"EUR": 1.1, "GBP": 1.25}
    return rates.get(currency.upper(), 1.0)

Now we assemble the agent:

agent = create_agent(
    model=llm,
    tools=[calculate_revenue, get_exchange_rate],
    system_prompt="You are a financial analysis assistant."
)

That’s it.

The agent now:

Decides when math is needed
Calls tools autonomously
Observes results
Produces a final answer

No manual routing logic.

3️⃣ Structured Outputs: Stop Parsing Strings

If you're still doing regex on LLM responses, stop.

Modern agents can return structured data using schemas.

from pydantic import BaseModel

class FinancialReport(BaseModel):
    revenue: float
    currency: str
    usd_value: float

Now we enforce structure:

structured_agent = create_agent(
    model=llm,
    tools=[calculate_revenue, get_exchange_rate],
    response_format=FinancialReport,
)

Now when you invoke:

response = structured_agent.invoke({
    "messages": [
        {"role": "user", "content": "I sold 120 units at 50 EUR each. Convert to USD."}
    ]
})

print(response)

You don’t get text.

You get validated data.
Using Pydantic structured output parsers ensures the datatype of the fields is based on how we defined it.

4️⃣ Memory: Making the Agent Stateful

Without memory, every request is a new message.

With memory, your agent becomes a collaborator.

In LangChain, memory can be plugged in via message history.

Example pattern:

chat_history = []

response = agent.invoke({
    "messages": chat_history + [
        {"role": "user", "content": "My product costs 20 USD."}
    ]
})

chat_history.extend(response["messages"])

response = agent.invoke({
    "messages": chat_history + [
        {"role": "user", "content": "Now calculate revenue for 300 units."}
    ]
})

Now the agent remembers:

Product price
Prior discussion
Contextual decisions

Memory transforms isolated responses into evolving workflows.

🧠 What’s Actually Happening Internally?

When you call:

agent.invoke(...)

The agent:

Reads conversation + system prompt
Plans next action
Chooses a tool (if needed)
Executes tool
Feeds result back into reasoning
Produces structured final output

This loop is grounded in tool-calling rather than fragile prompt tricks.

⚠️ Common Mistakes

Things beginner devs get wrong:

❌ Adding too many tools
❌ Writing vague tool descriptions
❌ Not enforcing structured outputs
❌ Forgetting observability/logging
❌ Letting the agent free-run without constraints

Agents are probabilistic planners — not deterministic scripts.

Design them intentionally.

🏗 The Big Shift in How We Build Software

Before agents:

APIs returned static responses
Business logic was deterministic
LLMs were “smart text generators”

After agents:

LLMs orchestrate execution
Tools become capabilities
Structure guarantees reliability
Memory enables continuity

You're no longer building chat interfaces.

You're building goal-driven systems.

🎯 Final Take

If your AI system:

Doesn’t use tools
Doesn’t enforce structure
Doesn’t maintain memory

It’s not an agent.

It’s autocomplete with better marketing.

With modern LangChain, the barrier to real agents is gone.

The question isn’t “Can we build agents?”

It’s:

What workflows are we ready to automate?

Do comment how you build agents and regarding any interesting types of agents you've built!

DEV Community