DEV Community: Sanskriti

I Baked a Football Cake and It Taught Me About Building AI Agents

Sanskriti — Sun, 30 Nov 2025 02:33:06 +0000

I recently baked a football cake and it helped me realize AI agents work just like layered desserts. Here’s how flavors, molds and icing maps to agentic design.

The code example below is designed to break down user goals into actionable steps and execute them using either custom tools or LLM reasoning. It uses regex to extract numbered steps from the LLM’s plan output. Executes each step by matching keywords like "search" or "compute" to the appropriate tool, or falls back to LLM reasoning.

Just like a custom cake has layers of flavor, structure, and decoration, an AI agent has its own stack.

It uses llama 3 LLM model and created two custom simple tools:

search_tool() - simulates a search engine returning mock results.
compute_tool() - simulates a computation task returning a placeholder result.

Implementing the agent architecture:

Base model: The sponge layer. I used llama 3, Ollama LLM model. It handles basic reasoning via the LLM.

# -------------------------------------------------------
# Ollama LLM Wrapper
# -------------------------------------------------------
class OllamaLLM:
    def __init__(self, model="llama3"):
        self.model = model

    def __call__(self, prompt: str) -> str:
        """Send a prompt to a local Ollama instance."""
        resp = requests.post(
            "http://localhost:11434/api/generate",
            json={"model": self.model, "prompt": prompt, "stream": False}
        )
        text = json.loads(resp.text).get("response", "")
        return text

# -------------------------------------------------------
# Base Agent 
# -------------------------------------------------------
class AgentCore:
    def __init__(self, llm):
        self.llm = llm

    def reason(self, prompt):
        return self.llm(prompt)

Tool execution: The icing and decor are the search and compute tools.

# -------------------------------------------------------
# Local Tools
# -------------------------------------------------------
def search_tool(query: str) -> dict:
    return {
        "tool": "search",
        "query": query,
        "results": [
            {"title": "Top NFL QBs 2024", "eff": 98.1},
            {"title": "Quarterback Rankings", "eff": 95.6},
        ],
    }


def compute_tool(task: str) -> dict:
    return {
        "tool": "compute",
        "task": task,
        "result": 42,  # we pretend the tool computed something important
    }

Prompt logic: Like flavor choices, it defines behavior. It adds step parsing and tool execution.

# -------------------------------------------------------
# Agent prompt and structured tool execution
# -------------------------------------------------------
class StructuredAgent(AgentCore):

    def parse_steps(self, plan: str):
        """Extract step lines starting with numbers."""
        lines = plan.split("\n")
        steps = []
        for line in lines:
            match = STEP_REGEX.search(line.strip())
            if match:
                cleaned = match.group(2).strip()
                steps.append(cleaned)
        return steps

    def execute_step(self, step: str):
        step_lower = step.lower()

        if "search" in step_lower:
            return search_tool(step)

        if "calculate" in step_lower or "compute" in step_lower:
            return compute_tool(step)

        # fallback: let the model reason
        return self.reason(step)

    def run(self, goal: str):
        PLAN_PROMPT =f"""You are a task decomposition engine.  
Your ONLY job is to break the user's goal into a small set of concrete, functional steps.
Your outputs MUST stay within the domain of the user’s goal.  
If the goal references football, metrics, or sports, remain in that domain only.

RULES:
- Only return steps directly needed to complete the user’s goal.
- Do NOT invent topics, examples, reviews, or unrelated domains.
- Do NOT expand into full explanations.
- No marketing language.
- No creative writing.
- No assumptions beyond the user's exact goal.
- No extra commentary.

FORMAT:
1. <short step>
2. <short step>
3. <short step>

User goal: "{goal}"
"""
        plan = self.llm(PLAN_PROMPT)
        steps = self.parse_steps(plan)

        outputs = []
        for step in steps:
            outputs.append({
                "step": step,
                "output": self.execute_step(step)
            })
        return outputs

User-facing output: The final taste = formatted responses. It formats the output for user facing responses.

# -------------------------------------------------------
# User Facing Agent (Formatted Output Layer)
# -------------------------------------------------------
class FinalAgent(StructuredAgent):
    def respond(self, goal: str):
        results = self.run(goal)

        formatted = "\n".join(
            f"- **{r['step']}** → {r['output']}"
            for r in results
        )

        return (
            f"## Result for goal: *{goal}*\n\n"
            f"{formatted}\n"
        )

Takeaway

Whether you're baking or writing code, structure matters. Think in layers. And if you ever need a sweet analogy to explain AI agents try cake. Got a dev inspired dessert metaphor? Drop it in the comments and let’s make tech tasty.

Tutorial

System Requirements:
Python version: 3.11.6
Ollama: Install and run Ollama locally to serve the Llama 3 model.

import requests
import json
import re

# parser that detects all common LLM step styles, including:
# 1. Do X
# 1) Do X
# Step 1: Do X
# **Step 1:** Do X
# - Step 1: Do X
# ### Step 1
# Step One:

STEP_REGEX = re.compile(
    r"(?:^|\s)(?:\*\*)?(?:Step\s*)?(\d+)[\.\):\- ]+(.*)", re.IGNORECASE
)



# -------------------------------------------------------
# Ollama LLM Wrapper
# -------------------------------------------------------
class OllamaLLM:
    def __init__(self, model="llama3"):
        self.model = model

    def __call__(self, prompt: str) -> str:
        """Send a prompt to a local Ollama instance."""
        resp = requests.post(
            "http://localhost:11434/api/generate",
            json={"model": self.model, "prompt": prompt, "stream": False}
        )
        text = json.loads(resp.text).get("response", "")
        return text

# -------------------------------------------------------
# Base Agent 
# -------------------------------------------------------
class AgentCore:
    def __init__(self, llm):
        self.llm = llm

    def reason(self, prompt):
        return self.llm(prompt)

# -------------------------------------------------------
# Local Tools
# -------------------------------------------------------
def search_tool(query: str) -> dict:
    return {
        "tool": "search",
        "query": query,
        "results": [
            {"title": "Top NFL QBs 2024", "eff": 98.1},
            {"title": "Quarterback Rankings", "eff": 95.6},
        ],
    }


def compute_tool(task: str) -> dict:
    return {
        "tool": "compute",
        "task": task,
        "result": 42,  # we pretend the tool computed something important
    }



# -------------------------------------------------------
# Agent prompt and structured tool execution
# -------------------------------------------------------
class StructuredAgent(AgentCore):

    def parse_steps(self, plan: str):
        """Extract step lines starting with numbers."""
        lines = plan.split("\n")
        steps = []
        for line in lines:
            match = STEP_REGEX.search(line.strip())
            if match:
                cleaned = match.group(2).strip()
                steps.append(cleaned)
        return steps

    def execute_step(self, step: str):
        step_lower = step.lower()

        if "search" in step_lower:
            return search_tool(step)

        if "calculate" in step_lower or "compute" in step_lower:
            return compute_tool(step)

        # fallback: let the model reason
        return self.reason(step)

    def run(self, goal: str):
        PLAN_PROMPT =f"""You are a task decomposition engine.  
Your ONLY job is to break the user's goal into a small set of concrete, functional steps.
Your outputs MUST stay within the domain of the user’s goal.  
If the goal references football, metrics, or sports, remain in that domain only.

RULES:
- Only return steps directly needed to complete the user’s goal.
- Do NOT invent topics, examples, reviews, or unrelated domains.
- Do NOT expand into full explanations.
- No marketing language.
- No creative writing.
- No assumptions beyond the user's exact goal.
- No extra commentary.

FORMAT:
1. <short step>
2. <short step>
3. <short step>

User goal: "{goal}"
"""
        plan = self.llm(PLAN_PROMPT)
        steps = self.parse_steps(plan)

        outputs = []
        for step in steps:
            outputs.append({
                "step": step,
                "output": self.execute_step(step)
            })
        return outputs


# -------------------------------------------------------
# User Facing Agent (Formatted Output Layer)
# -------------------------------------------------------
class FinalAgent(StructuredAgent):
    def respond(self, goal: str):
        results = self.run(goal)

        formatted = "\n".join(
            f"- **{r['step']}** → {r['output']}"
            for r in results
        )

        return (
            f"## Result for goal: *{goal}*\n\n"
            f"{formatted}\n"
        )


# -------------------------------------------------------
# Test Cases
# -------------------------------------------------------
if __name__ == "__main__":
    agent = FinalAgent(llm=OllamaLLM("llama3"))

    tests = [
        "Compare NFL quarterback efficiency metrics and summarize insights.",
        "Search for top training drills for youth football players.",
        "Compute a simple metric and explain how you'd structure the process.",
    ]

    for i, t in enumerate(tests, 1):
        print("=" * 70)
        print(f"TEST {i}: {t}")
        print(agent.respond(t))
        print()

Sample Output

======================================================================
TEST 1: Compare NFL quarterback efficiency metrics and summarize insights.

Result for goal: Compare NFL quarterback efficiency metrics and summarize insights.

Gather data on NFL quarterback statistics → Here are some key statistics for NFL quarterbacks, gathered from various sources including Pro-Football-Reference.com, ESPN, and NFL.com:

Passing Statistics

Career Passing Yards: + Tom Brady: 73,517 yards (most in NFL history) + Drew Brees: 72,503 yards + Peyton Manning: 71,940 yards
Career Touchdowns: + Tom Brady: 624 touchdowns + Drew Brees: 571 touchdowns + Aaron Rodgers: 462 touchdowns
Interceptions: + Brett Favre: 336 interceptions (most in NFL history) + Eli Manning: 244 interceptions + Philip Rivers: 234 interceptions
Completion Percentage: + Aaron Rodgers: 65.5% completion percentage (highest in NFL history) + Drew Brees: 64.7% + Tom Brady: 63.4%

Rushing Statistics

Career Rushing Yards: + Cam Newton: 5,442 yards + Russell Wilson: 3,911 yards + Michael Vick: 3,844 yards
Career Rushing Touchdowns: + Cam Newton: 85 rushing touchdowns (most among QBs) + Russell Wilson: 44 rushing touchdowns + Michael Vick: 36 rushing touchdowns

Other Statistics

Win-Loss Record: + Tom Brady: 230-72 regular season record (best among QBs) + Drew Brees: 208-115 regular season record + Peyton Manning: 208-141 regular season record
Playoff Wins: + Tom Brady: 32 playoff wins (most in NFL history) + Joe Montana: 23 playoff wins + Terry Bradshaw: 20 playoff wins

Note: These statistics are accurate as of the end of the 2020 NFL season and may change over time.

I hope this helps! Let me know if you have any specific questions or if there's anything else I can help with.

Identify relevant efficiency metrics (e.g., passer rating, yards per attempt) → Here are some common efficiency metrics used to evaluate quarterbacks:

Passer Rating: A quarterback's cumulative performance based on completion percentage, yards per attempt, touchdowns, and interceptions. * Formula: (Completions - Attempts + Touchdowns * 5 + Interceptions * -2) / Attempted Passes
Yards Per Attempt (YPA): Measures a quarterback's average yardage gained per pass attempt.
Completion Percentage: The percentage of passes completed out of total attempts.
Touchdown-to-Interception Ratio: Evaluates a quarterback's ability to score touchdowns compared to throwing interceptions.
Red Zone Efficiency: Measures a quarterback's success in scoring touchdowns within the opponent's 20-yard line (e.g., red zone).
Third Down Conversion Percentage: Assesses a quarterback's ability to convert third-down plays into first downs.
Fourth Quarter Points Per Game: Evaluates a quarterback's performance in critical, late-game situations.
Adjusted Net Yards Per Attempt (ANY/A): A more advanced metric that adjusts for opponent strength and incorporates additional factors like sacks and fumbles.

Other efficiency metrics used to evaluate quarterbacks include:

Quarterback Wins: A simple measure of a quarterback's contribution to their team's win-loss record.
Passer Rating Average per Game: A variation of the traditional passer rating formula, adjusted for games played.
Sack Rate: Measures a quarterback's frequency of being sacked relative to their total pass attempts.
Fumble Rate: Evaluates a quarterback's tendency to fumble the ball relative to their total pass attempts.

Keep in mind that each metric has its strengths and weaknesses, and no single efficiency metric can fully capture a quarterback's performance.

Calculate averages and rankings for each quarterback → {'tool': 'compute', 'task': 'Calculate averages and rankings for each quarterback', 'result': 42}

How AI Thinks It Thinks: ChatGPT, Copilot and Gemini Explain Themselves

Sanskriti — Tue, 02 Sep 2025 04:26:06 +0000

When building LangChain agents, understanding how your LLM "reasons" isn’t just a technical curiosity, it’s critical for debugging. They operate as probabilistic engines trained on vast datasets, generating outputs that mimic reasoning, planning, and even self awareness. Whether they’re glorified autocomplete systems or emergent cognitive frameworks, they’re shaping how we build, debug, and deploy intelligent workflows. To truly understand what these models can and can’t do, I went straight to the source. I prompted ChatGPT, Microsoft Copilot, and Google Gemini to explain their own architecture, reasoning process, and limitations. The best way to learn how they think is to ask them to think about themselves. Here’s what they said.

Questions Asked

How do you work?
Can you explain more technically?
What’s the actual math behind it?
How do you create your own output with reason if all you are doing is token prediction?
Can you explain it step by step like I’m 5?
What are your limitations today?

Response Summary

Question	ChatGPT	Copilot	Gemini
1. How do you work?	Describes token prediction, training on large datasets, and emergent reasoning.	Explains transformer architecture and modular orchestration.	Covers transformer basics and training data.
2. Can you explain more technically?	Introduces embeddings, attention, and sampling with equations.	Details inference pipeline, memory, and tool integration.	Describes self-attention and model layers.
3. What’s the actual math behind it?	Shares softmax and sampling logic.	Explains conditional probability and token scoring.	Mentions attention weights and vector math.
4. How do you create your own output with reason if all you are doing is token prediction?	Frames reasoning as emergent behavior from token selection.	Simulates reasoning and planning via intermediate steps and tool calls.	Says reasoning emerges from scale and training.
5. Can you explain it step by step like I’m 5?	Uses analogies like smart autocomplete and storytelling.	Describes step-by-step planning like a checklist.	Uses library and storytelling metaphors.
6. What are your limitations today?	Hallucinations, context limits, bias, no memory.	No consciousness, no intent, sandboxed tools.	Hallucinations, bias, static knowledge, no real reasoning.

Verdict: Who Explained It Best?

Model	Clarity	Depth	Conciseness	Dev Utility
ChatGPT	Y	Y	Y	Y
Copilot	Y	Y	Y	Y
Gemini	Y	Maybe	Maybe	Maybe

Legend - Y (It's able to explain in detail); Maybe (Somewhat explained it)

Takeaway for Agent Builders

If you're designing agents that need to simulate reasoning, learn and make decisions. Copilot’s modular thinking and planning metaphors are especially useful. ChatGPT is great for understanding the math and mechanics. Gemini is fine but less actionable.

Don't forget to try it on your own and let's discuss in the comments.

Versions used -
Gemini 2.5 Flash
Copilot Quick Response Mode
ChatGPT GPT-5

LangChain + Ollama in the Wild: Hard Learned Lessons on Building a Custom LLM Agent

Sanskriti — Wed, 20 Aug 2025 05:32:18 +0000

I stumbled upon Ollama, an open-source application that makes it easy to run large language models locally with minimal setup. Integrating LangChain with Ollama is straightforward: you can wire up a model with just a few lines of code.

Turning that integration into shippable code, something reliable enough to move beyond a demo requires more care. Through trial and error, I ran into several pitfalls that made the difference between a quick prototype and a stable system.

For this article, I’ll use a simple scheduling agent as the example to walk through four key lessons.

src-https://ollama.com/public/blog/meta-ollama-llama3.png

1. Skipping Explicit Schemas

If you let the model “be concise,” it will drift into natural language instead of structured outputs. The fix is to define JSON schemas directly in the system prompt.

SYSTEM_PROMPT = """
You are a calendaring assistant. Actions:

1. create_meeting
   { "person": string, "datetime": string, "reason": string }

2. reschedule_meeting
   { "person": string, "new_datetime": string }

3. cancel_meeting
   { "person": string }

4. escalate_issue
   { "reason": string }

Output only valid JSON:
{ "action": "<name>", "input": {...} }
"""

2. Post Processing Is Not Optional

Even with a schema, the model sometimes returns almost JSON: stray commas, comments, or text. That’s why you should always sanitize before parsing.

import re, json

def clean_json(payload: str) -> str:
    no_comments = re.sub(r'//.*', '', payload)
    return re.sub(r',(\s*[}\]])', r'\1', no_comments).strip()

def parse_payload(raw: str):
    payload = clean_json(raw)
    return json.loads(payload)

3. No Timeouts/Retries

Network hiccups or model stalls will block your system if you don’t enforce limits. Ollama doesn’t provide retries or timeouts out of the box, so you need to add them at the call site.

from langchain_ollama import ChatOllama
from langchain.schema import SystemMessage, HumanMessage

llm = ChatOllama(model="llama3", temperature=0)

def call_with_retry(messages, retries=2):
    for attempt in range(retries):
        try:
            return llm.invoke(input=messages, timeout=10)  # enforce timeout
        except Exception:
            if attempt == retries - 1:
                raise

4. Ignoring Drifts

As prompts or models change, outputs can silently drift. A schema that worked last week may suddenly fail. Adding lightweight regression checks helps you catch this early.

def test_golden_case():
    messages = [SystemMessage(content=SYSTEM_PROMPT),
                HumanMessage(content="Book a lunch with Alex at 1pm")]
    ai_msg = call_with_retry(messages)
    cmd = parse_payload(ai_msg.content)
    assert "action" in cmd and "input" in cmd

Putting It Together:

import json, re
from langchain_ollama import ChatOllama
from langchain.schema import SystemMessage, HumanMessage, AIMessage

# 1) Define your agent meeting functions as JSON in the system prompt
SYSTEM_PROMPT = """
You are a calendaring assistant. Actions:

1. create_meeting
   { "person": string, "datetime": string, "reason": string }

2. reschedule_meeting
   { "person": string, "new_datetime": string }

3. cancel_meeting
   { "person": string }

4. escalate_issue
   { "reason": string }

Output only valid JSON:
{ "action": "<name>", "input": {...} }
"""

# 2) Init the Ollama model
llm = ChatOllama(model="llama3", temperature=0)

# 3) AI message as cleaned up JSON
def parse_payload(raw: str):
    payload = clean_json(raw)
    return json.loads(payload)

# 4) Remove any JS-style comments and trailing commas in objects/arrays
def clean_json(payload: str) -> str:
    no_comments = re.sub(r'//.*', '', payload)
    return re.sub(r',(\s*[}\]])', r'\1', no_comments).strip()

# 5) Invoke llm model with retry limit
def call_with_retry(messages, retries=2):
    for attempt in range(retries):
        try:
            return llm.invoke(input=messages)
        except Exception:
            if attempt == retries - 1:
                raise

# 6) Execute custom agent and to return the result
def run_agent(user_request: str):
    messages = [SystemMessage(content=SYSTEM_PROMPT), HumanMessage(content=user_request)]
    ai_msg: AIMessage = call_with_retry(messages)
    cmd = parse_payload(ai_msg.content)

    action, params = cmd["action"], cmd["input"]

    if action == "create_meeting":
        return {"result": f"Created meeting with {params['person']} on {params['datetime']}"}

    elif action == "reschedule_meeting":
        return {"result": f"Rescheduled {params['person']} to {params['new_datetime']}"}

    elif action == "cancel_meeting":
        return {"result": f"Cancelled meeting with {params['person']}"}

    elif action == "escalate_issue":
        return {"result": f"Escalated due to: {params['reason']}"}

    else:
        return {"error": f"Unknown action: {action}"}

# 7) Optional - regression check
def test_golden_case():
    messages = [SystemMessage(content=SYSTEM_PROMPT),
                HumanMessage(content="Reschedule a lunch with Alex at 1pm")]
    ai_msg = call_with_retry(messages)
    cmd = parse_payload(ai_msg.content)
    print(cmd["action"])
    print(cmd["input"])
    assert "action" in cmd and "input" in cmd

# Application start
if __name__ == "__main__":
    query = "Book a call with Mr. Russell for next Thursday at 3 PST for a quick lunch"
    print(run_agent(query))
    # Optional validation step
    #test_golden_case()

O/P: {'result': 'Created meeting with Mr. Russell on 2023-03-16T15:00:00-08:00'}

Takeaway

LangChain + Ollama is fast to set up, but brittle if you skip guardrails. These small investments turn a fragile code into a service you can trust.

QQ???

Ollama updated lib now supports tools, so would you wrap dispatch logic into a proper toolset (using LangChain Tool abstraction) or keep it closer to plain Python for control?