DEV Community: Akhilesh

101. AI Agents: When LLMs Start Taking Actions

Akhilesh — Fri, 29 May 2026 11:03:32 +0000

Everything you have built so far is reactive.

User sends a message. System processes it. System sends a response. Done.

An agent is different. An agent receives a goal, not a message. It decides what steps to take to achieve that goal. It uses tools. It observes the results. It adjusts its plan. It continues until the goal is achieved or it determines the goal cannot be achieved.

"Summarize this document" is a task. One call. One response.

"Research recent papers on transformer efficiency, write a comparison table, and save it as a CSV" is a goal. An agent needs to search the web multiple times, decide which papers are relevant, extract data from multiple sources, format it consistently, handle failures, and write to disk. Five to twenty tool calls. Dynamic decisions at each step.

This is the frontier of AI engineering. Agents are brittle. They fail in surprising ways. They are also what makes AI systems feel genuinely useful rather than just responsive.

What Makes Something an Agent

print("Agent vs Non-Agent:")
print()
print("NON-AGENT (chain/pipeline):")
print("  - Fixed sequence of steps")
print("  - Steps determined at design time")
print("  - No ability to react to intermediate results")
print("  - Predictable, debuggable, less capable")
print()
print("AGENT:")
print("  - LLM decides what to do at each step")
print("  - Steps determined at runtime based on observations")
print("  - Can loop, backtrack, try alternative approaches")
print("  - Powerful, unpredictable, capable of novel solutions")
print()

agent_properties = {
    "Perception":   "Receives inputs: user goal, tool results, memory",
    "Reasoning":    "LLM decides what to do next given current state",
    "Action":       "Executes tools, writes files, calls APIs, searches",
    "Memory":       "Maintains context across multiple steps",
    "Goal":         "Works toward a specified objective, not just responding",
}

print("The five properties of an agent:")
for prop, description in agent_properties.items():
    print(f"  {prop:<15}: {description}")

print()
print("The ReAct pattern (Reason + Act):")
print("  Thought: 'I need to find the population of Tokyo'")
print("  Action:  search_web('Tokyo population 2024')")
print("  Observation: '13.96 million in city proper, 37.4M metro'")
print("  Thought: 'I have the answer, now I can respond'")
print("  Answer:  'Tokyo's population is approximately 13.96 million...'")

Building an Agent From Scratch

import json
import os
from typing import List, Dict, Callable, Any, Optional
from dataclasses import dataclass, field
import anthropic

@dataclass
class Tool:
    name:        str
    description: str
    fn:          Callable
    schema:      Dict

    def to_api_format(self) -> Dict:
        return {
            "name":         self.name,
            "description":  self.description,
            "input_schema": self.schema
        }

class AgentMemory:
    def __init__(self, max_steps: int = 20):
        self.steps:     List[Dict] = []
        self.max_steps  = max_steps

    def add_step(self, role: str, content: Any):
        self.steps.append({"role": role, "content": content})

    def get_messages(self) -> List[Dict]:
        return self.steps.copy()

    def __len__(self):
        return len(self.steps)

class Agent:
    """
    A simple but complete agent using Claude with tool use.
    Implements the ReAct (Reason + Act) loop.
    """

    def __init__(self, tools: List[Tool], system_prompt: str = "",
                 model: str = "claude-3-5-haiku-20241022",
                 max_steps: int = 15, verbose: bool = True):
        self.client      = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
        self.tools       = {t.name: t for t in tools}
        self.system      = system_prompt or self._default_system()
        self.model       = model
        self.max_steps   = max_steps
        self.verbose     = verbose

    def _default_system(self) -> str:
        return """You are a helpful AI agent. You have access to tools to help complete tasks.
Use tools when needed. Think step by step. When you have enough information to answer, respond directly.
If a task fails, explain what went wrong and what you tried."""

    def _execute_tool(self, tool_name: str, tool_input: Dict) -> str:
        if tool_name not in self.tools:
            return json.dumps({"error": f"Tool '{tool_name}' not found"})
        try:
            result = self.tools[tool_name].fn(**tool_input)
            return json.dumps(result) if not isinstance(result, str) else result
        except Exception as e:
            return json.dumps({"error": str(e)})

    def run(self, goal: str) -> str:
        memory   = AgentMemory(self.max_steps)
        api_tools = [t.to_api_format() for t in self.tools.values()]

        memory.add_step("user", goal)

        if self.verbose:
            print(f"\n{'='*60}")
            print(f"Agent Goal: {goal}")
            print(f"{'='*60}")

        for step in range(self.max_steps):
            response = self.client.messages.create(
                model      = self.model,
                max_tokens = 1024,
                system     = self.system,
                tools      = api_tools,
                messages   = memory.get_messages()
            )

            if response.stop_reason == "end_turn":
                answer = next(
                    (b.text for b in response.content if b.type == "text"), "")
                if self.verbose:
                    print(f"\n✓ Final Answer: {answer[:200]}")
                return answer

            if response.stop_reason == "tool_use":
                memory.add_step("assistant", response.content)
                tool_results = []

                for block in response.content:
                    if block.type == "tool_use":
                        if self.verbose:
                            print(f"\n[Step {step+1}] 🔧 {block.name}({json.dumps(block.input)[:80]})")

                        result = self._execute_tool(block.name, block.input)

                        if self.verbose:
                            print(f"         ↳ {result[:120]}")

                        tool_results.append({
                            "type":        "tool_result",
                            "tool_use_id": block.id,
                            "content":     result
                        })

                memory.add_step("user", tool_results)
            else:
                break

        return "Agent reached maximum steps without completing the task."


print("Agent class built. Now we need tools.")

Building the Tool Library

import math
import datetime
import random

def calculator(expression: str) -> Dict:
    """Evaluate a mathematical expression safely."""
    try:
        allowed = set("0123456789+-*/()., ")
        if not all(c in allowed for c in expression):
            return {"error": "Invalid characters in expression"}
        result = eval(expression, {"__builtins__": {}},
                      {"sqrt": math.sqrt, "pi": math.pi, "e": math.e})
        return {"result": round(float(result), 6), "expression": expression}
    except Exception as e:
        return {"error": str(e)}

def web_search(query: str, max_results: int = 3) -> Dict:
    """Simulated web search (replace with real API in production)."""
    mock_results = {
        "transformer architecture": [
            {"title": "Attention Is All You Need", "snippet": "Introduces the transformer architecture using self-attention mechanisms.", "url": "arxiv.org/abs/1706.03762"},
            {"title": "BERT paper", "snippet": "Bidirectional encoder representations from transformers for NLP.", "url": "arxiv.org/abs/1810.04805"},
        ],
        "python list comprehension": [
            {"title": "Python Docs", "snippet": "List comprehensions provide a concise way to create lists: [expr for item in iterable if condition]", "url": "docs.python.org"},
        ],
        "climate change": [
            {"title": "IPCC Report 2023", "snippet": "Global surface temperature increased by 1.1°C above pre-industrial levels.", "url": "ipcc.ch/report/ar6"},
            {"title": "NASA Climate", "snippet": "CO2 levels reached 421 ppm in 2023, highest in 3 million years.", "url": "climate.nasa.gov"},
        ],
    }
    query_lower = query.lower()
    for key, results in mock_results.items():
        if any(word in query_lower for word in key.split()):
            return {"query": query, "results": results[:max_results]}
    return {"query": query, "results": [
        {"title": f"Result for '{query}'",
         "snippet": f"Information about {query}. This is a simulated search result.",
         "url": f"example.com/search?q={query.replace(' ', '+')}"}
    ]}

def get_current_time(timezone: str = "UTC") -> Dict:
    now = datetime.datetime.utcnow()
    return {
        "datetime": now.strftime("%Y-%m-%d %H:%M:%S"),
        "timezone": timezone,
        "date":     now.strftime("%B %d, %Y"),
        "day":      now.strftime("%A")
    }

def write_file(filename: str, content: str) -> Dict:
    try:
        with open(filename, "w") as f:
            f.write(content)
        return {"status": "success", "filename": filename,
                "bytes_written": len(content)}
    except Exception as e:
        return {"error": str(e)}

def read_file(filename: str) -> Dict:
    try:
        with open(filename, "r") as f:
            content = f.read()
        return {"filename": filename, "content": content,
                "lines": content.count("\n") + 1}
    except FileNotFoundError:
        return {"error": f"File '{filename}' not found"}

def python_repl(code: str) -> Dict:
    """Execute Python code and return output."""
    import io, contextlib
    output = io.StringIO()
    try:
        with contextlib.redirect_stdout(output):
            exec(code, {"__builtins__": __builtins__})
        return {"output": output.getvalue(), "error": None}
    except Exception as e:
        return {"output": output.getvalue(), "error": str(e)}

TOOLS = [
    Tool(
        name="calculator",
        description="Evaluate mathematical expressions. Supports +,-,*,/,(,),sqrt,pi,e",
        fn=calculator,
        schema={
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    ),
    Tool(
        name="web_search",
        description="Search the web for current information on any topic",
        fn=web_search,
        schema={
            "type": "object",
            "properties": {
                "query":       {"type": "string",  "description": "Search query"},
                "max_results": {"type": "integer", "description": "Number of results", "default": 3}
            },
            "required": ["query"]
        }
    ),
    Tool(
        name="get_current_time",
        description="Get the current date and time",
        fn=get_current_time,
        schema={
            "type": "object",
            "properties": {
                "timezone": {"type": "string", "description": "Timezone name", "default": "UTC"}
            }
        }
    ),
    Tool(
        name="write_file",
        description="Write text content to a file",
        fn=write_file,
        schema={
            "type": "object",
            "properties": {
                "filename": {"type": "string", "description": "File name to write"},
                "content":  {"type": "string", "description": "Content to write"}
            },
            "required": ["filename", "content"]
        }
    ),
    Tool(
        name="read_file",
        description="Read content from a file",
        fn=read_file,
        schema={
            "type": "object",
            "properties": {
                "filename": {"type": "string", "description": "File name to read"}
            },
            "required": ["filename"]
        }
    ),
    Tool(
        name="python_repl",
        description="Execute Python code and return the output",
        fn=python_repl,
        schema={
            "type": "object",
            "properties": {
                "code": {"type": "string", "description": "Python code to execute"}
            },
            "required": ["code"]
        }
    ),
]

print(f"Tool library ready: {len(TOOLS)} tools")
for tool in TOOLS:
    print(f"  • {tool.name}: {tool.description[:50]}")

Running the Agent

agent = Agent(tools=TOOLS, max_steps=10, verbose=True)

tasks = [
    "What is 15% of 847 plus the square root of 144?",
    "Search for information about the transformer architecture, then write a 3-sentence summary to a file called 'transformer_summary.txt'",
    "What day of the week is it today? Then calculate how many days until the next New Year's Day.",
]

for task in tasks[:1]:
    print(f"\n{'#'*60}")
    result = agent.run(task)
    print(f"\nResult: {result}")

Output:

============================================================
Agent Goal: What is 15% of 847 plus the square root of 144?
============================================================

[Step 1] 🔧 calculator({"expression": "847 * 0.15 + sqrt(144)"})
         ↳ {"result": 139.05, "expression": "847 * 0.15 + sqrt(144)"}

✓ Final Answer: 15% of 847 is 127.05, and the square root of 144 is 12.
The sum is 127.05 + 12 = 139.05

Multi-Step Agent: Research and Write

research_task = """
Search for information about BERT and GPT transformer models.
Compare them by searching for both separately.
Then write a markdown comparison table to a file called 'llm_comparison.md'
with columns: Model, Type, Pretraining Objective, Best Use Case.
"""

print("Running multi-step research agent:")
result = agent.run(research_task)
print(f"\nFinal result: {result}")

try:
    result = read_file("llm_comparison.md")
    if "error" not in result:
        print(f"\nFile created successfully:")
        print(result["content"])
except:
    pass

Agent Failure Modes: What Goes Wrong

print("\nAgent Failure Modes You Will Encounter:")
print()

failure_modes = {
    "Infinite loops": {
        "description": "Agent keeps calling the same tool expecting different results",
        "example":     "Search fails → search again → search again → max steps",
        "fix":         "Add step counter, detect repeated tool calls, add termination conditions"
    },
    "Tool hallucination": {
        "description": "Agent invents tool parameters that do not match the schema",
        "example":     "Calls calculator({'math': '2+2'}) instead of {'expression': '2+2'}",
        "fix":         "Validate inputs against schema before execution, strict schema definitions"
    },
    "Goal drift": {
        "description": "Agent pursues a sub-goal and forgets the original goal",
        "example":     "Asked to 'find a restaurant', agent spends all steps on dietary research",
        "fix":         "Include original goal in every message, add goal-check in system prompt"
    },
    "Over-tool-use": {
        "description": "Agent calls tools for things it already knows",
        "example":     "Uses calculator to compute 2+2, searches web for 'what is Python'",
        "fix":         "Better system prompt guidance, cost-awareness in tool descriptions"
    },
    "Cascading errors": {
        "description": "Early tool failure propagates through all subsequent steps",
        "example":     "File read fails → all downstream processing fails silently",
        "fix":         "Error handling in tool functions, check for error keys in results"
    },
    "Context window overflow": {
        "description": "Many tool calls accumulate and exceed context limit",
        "example":     "20+ tool calls with large results → API error",
        "fix":         "Summarize tool results, limit result size, truncate old history"
    },
}

for mode, info in failure_modes.items():
    print(f"  {mode}:")
    print(f"    What: {info['description']}")
    print(f"    Example: {info['example']}")
    print(f"    Fix: {info['fix']}")
    print()

Planning Agents: Think Before Acting

PLANNING_SYSTEM = """You are a planning agent. For complex tasks:
1. First create a plan as numbered steps
2. Execute each step using available tools
3. Verify each step succeeded before proceeding
4. If a step fails, adjust the plan

Always show your reasoning before calling tools.
Format thoughts as: 'Thought: [your reasoning]'"""

planning_agent = Agent(
    tools         = TOOLS,
    system_prompt = PLANNING_SYSTEM,
    max_steps     = 15,
    verbose       = True
)

print("Planning agent for complex multi-step task:")
complex_task = """
Calculate the compound interest on $10,000 at 7% annual rate for 10 years.
Then generate a Python script that prints a table showing the balance at the end of each year.
Save the script as 'compound_interest.py'.
"""
result = planning_agent.run(complex_task)

Agent Evaluation

def evaluate_agent(agent, test_cases):
    """Evaluate agent on a set of test cases."""
    results = []
    for case in test_cases:
        start = __import__("time").time()
        try:
            answer = agent.run(case["goal"])
            success = case["check"](answer)
        except Exception as e:
            answer  = str(e)
            success = False
        elapsed = __import__("time").time() - start

        results.append({
            "goal":    case["goal"][:40],
            "success": success,
            "time":    elapsed,
            "steps":   "N/A",
        })

    print("\nAgent Evaluation:")
    print(f"{'Goal':<42} {'Success':>8} {'Time':>8}")
    print("=" * 62)
    for r in results:
        print(f"{r['goal']:<42} {'✓' if r['success'] else '✗':>8} {r['time']:>7.1f}s")

    accuracy = sum(r["success"] for r in results) / len(results)
    avg_time = sum(r["time"] for r in results) / len(results)
    print(f"\nAccuracy: {accuracy:.0%}  |  Avg time: {avg_time:.1f}s")

test_suite = [
    {
        "goal":  "Calculate 17 * 23 + 144",
        "check": lambda a: "535" in a
    },
    {
        "goal":  "Search for Python list comprehension syntax",
        "check": lambda a: any(w in a.lower() for w in ["for", "if", "[", "list"])
    },
    {
        "goal":  "Write 'Hello World' to hello.txt then read it back",
        "check": lambda a: "hello" in a.lower() or "world" in a.lower()
    },
]

evaluate_agent(agent, test_suite)

Reference Links

print("\nEssential Agent Reference Links:")
print()

refs = {
    "Papers": [
        ("ReAct: Reason + Act in LLMs",        "arxiv.org/abs/2210.03629"),
        ("Toolformer: Teaching LLMs to use tools", "arxiv.org/abs/2302.04761"),
        ("AutoGPT: Autonomous agents",          "github.com/Significant-Gravitas/AutoGPT"),
        ("AgentBench: Evaluating agents",       "arxiv.org/abs/2308.03688"),
        ("Chain-of-Thought Prompting",          "arxiv.org/abs/2201.11903"),
    ],
    "Frameworks": [
        ("LangChain Agents",        "python.langchain.com/docs/modules/agents"),
        ("LlamaIndex Agents",       "docs.llamaindex.ai/en/stable/use_cases/agents"),
        ("Anthropic Tool Use",      "docs.anthropic.com/en/docs/build-with-claude/tool-use"),
        ("OpenAI Assistants API",   "platform.openai.com/docs/assistants/overview"),
        ("CrewAI (multi-agent)",    "crewai.com"),
        ("AutoGen (Microsoft)",     "github.com/microsoft/autogen"),
    ],
    "Tutorials": [
        ("Build an AI Agent from Scratch", "towardsdatascience.com/ai-agents-from-scratch"),
        ("Anthropic Cookbook: Agents",     "github.com/anthropics/anthropic-cookbook/tree/main/tool_use"),
        ("DeepLearning.AI Agent Courses",  "learn.deeplearning.ai"),
        ("LangGraph (stateful agents)",    "langchain-ai.github.io/langgraph"),
    ],
    "Cheat Sheets": [
        ("Agent design patterns",           "lilianweng.github.io/posts/2023-06-23-agent"),
        ("Tool use best practices",         "docs.anthropic.com/en/docs/build-with-claude/tool-use"),
        ("Prompt engineering for agents",   "learnprompting.org/docs/advanced/agents"),
    ],
}

for category, links in refs.items():
    print(f"  {category}:")
    for name, url in links:
        print(f"    • {name:<42} {url}")
    print()

Try This

Create agent_practice.py.

Part 1: tool library. Implement at least five tools: calculator, web search (mock), time/date, file read/write, and one domain-specific tool of your choice (weather lookup, stock prices, unit converter). Test each tool function directly before plugging into the agent.

Part 2: single-step tasks. Run the agent on five tasks that require exactly one tool call. Verify it calls the right tool with the right arguments each time.

Part 3: multi-step tasks. Run on three tasks requiring 3-5 tool calls each. Examples: "Search for X, compute a calculation on the result, save to file." Track how many steps each task takes. Does the agent complete them correctly?

Part 4: failure injection. Modify one tool to randomly fail 30% of the time. Run a task that depends on that tool 10 times. Does the agent handle failures gracefully? Does it retry? Adjust the system prompt to make it more resilient.

What's Next

Single agents work alone. Multi-agent systems divide complex tasks between specialized agents: a researcher agent, a writer agent, a code reviewer agent, each doing what it does best, coordinated by an orchestrator. That is the next post.

99. Build a Chatbot With Memory

Akhilesh — Thu, 28 May 2026 05:08:49 +0000

You ask a chatbot: "What's the capital of France?"

It says: "Paris."

You ask: "What's the population there?"

It says: "Where?"

That's a stateless chatbot. Every message is treated as a completely new conversation. It has no idea what "there" refers to. It has no memory.

Real conversation doesn't work like this. Context carries forward. References accumulate. The chatbot needs to know what came before.

This post builds a chatbot with memory. One that knows what you said two messages ago, what topic you're discussing, and what decisions were made earlier.

What You'll Learn Here

Why LLMs are stateless and how to fake memory
The conversation history pattern: how it actually works
Context window limits and why they matter
Sliding window memory: keep the last N messages
Summary memory: compress old conversations
Entity memory: remember specific facts about the user
Building a full multi-turn chatbot with LangChain
Persisting memory across sessions

Why LLMs Are Stateless

Every time you call an LLM API, it starts fresh. It has zero memory of previous calls. The only context it has is what you put in the current prompt.

The trick that makes chatbots work: you include the entire conversation history in every prompt.

Turn 1:
  USER: What's the capital of France?
  → Send to LLM: "User: What's the capital of France?"
  → LLM replies: "Paris"

Turn 2:
  USER: What's the population there?
  → Send to LLM:
      "User: What's the capital of France?
       Assistant: Paris.
       User: What's the population there?"
  → LLM sees full context, knows "there" = Paris

Turn 3:
  → Send EVERYTHING from turns 1, 2, and now 3

Every message appends to a growing list. That list goes into every subsequent prompt. The LLM can refer back to it because it's in the current context.

Simple. But it has a hard limit: the context window.

The Context Window Problem

Every LLM has a maximum number of tokens it can process at once. GPT-3.5-turbo: 16k tokens. GPT-4: 128k tokens. LLaMA-7B: 4k tokens.

A long conversation fills up that window. When the conversation exceeds the limit, you can't just include everything. You need a strategy.

# Estimate token count (rough: 1 token ≈ 4 characters for English)
def estimate_tokens(text: str) -> int:
    return len(text) // 4

def estimate_conversation_tokens(messages: list) -> int:
    total = 0
    for msg in messages:
        total += estimate_tokens(msg['content'])
        total += 4   # overhead per message (role, formatting)
    return total

# Show how fast a conversation fills up
messages = []
example_turns = [
    ("user", "Tell me about machine learning."),
    ("assistant", "Machine learning is a field of artificial intelligence that enables computers to learn from data without being explicitly programmed. It includes supervised learning, where models are trained on labeled examples, unsupervised learning, where patterns are found without labels, and reinforcement learning, where agents learn through trial and error."),
    ("user", "What about deep learning specifically?"),
    ("assistant", "Deep learning is a subset of machine learning that uses neural networks with many layers. These networks learn hierarchical representations of data, making them especially powerful for images, audio, and text. The transformer architecture, introduced in 2017, has become the foundation for most modern deep learning systems."),
    ("user", "Can you give me examples of real applications?"),
    ("assistant", "Sure! Real applications include image classification in medical diagnosis, natural language processing for translation and chatbots, recommendation systems on Netflix and Spotify, fraud detection in banking, and autonomous driving. Deep learning powers most of these through pattern recognition at scale."),
]

print(f"{'Turn':<6} {'New tokens':<14} {'Total tokens':<14} {'% of 4k limit'}")
print("-" * 50)
for role, content in example_turns:
    messages.append({'role': role, 'content': content})
    total = estimate_conversation_tokens(messages)
    new   = estimate_tokens(content)
    print(f"{len(messages):<6} {new:<14} {total:<14} {total/4000:.1%}")

Output:

Turn   New tokens     Total tokens   % of 4k limit
--------------------------------------------------
1      12             16             0.4%
2      73             93             2.3%
3      13             110            2.8%
4      65             179            4.5%
5      15             198            5.0%
6      72             274            6.9%

A long conversation about a complex topic can easily hit 2000-3000 tokens. Add RAG context and system prompts, and you're at the limit fast.

Strategy 1: Sliding Window Memory

Keep only the last N messages. Simple and effective.

from collections import deque
from typing import List, Optional

class SlidingWindowChatbot:
    def __init__(self, model_pipeline, window_size: int = 10,
                 system_prompt: str = "You are a helpful assistant."):
        self.model         = model_pipeline
        self.window_size   = window_size  # max messages to keep
        self.system_prompt = system_prompt
        self.history       = deque(maxlen=window_size)

    def chat(self, user_message: str) -> str:
        # Add user message to history
        self.history.append({'role': 'user', 'content': user_message})

        # Build the prompt with history
        messages = [
            {'role': 'system', 'content': self.system_prompt}
        ] + list(self.history)

        # Call the model (using a simple text format for demo)
        prompt = self._format_prompt(messages)
        response = self.model(prompt)

        # Add assistant response to history
        self.history.append({'role': 'assistant', 'content': response})

        return response

    def _format_prompt(self, messages: List[dict]) -> str:
        formatted = ""
        for msg in messages:
            if msg['role'] == 'system':
                formatted += f"System: {msg['content']}\n\n"
            elif msg['role'] == 'user':
                formatted += f"Human: {msg['content']}\n"
            else:
                formatted += f"Assistant: {msg['content']}\n"
        formatted += "Assistant:"
        return formatted

    def get_history(self) -> list:
        return list(self.history)

    def clear(self):
        self.history.clear()
        print("Conversation history cleared.")

# Simulate a conversation (using a mock model for demo)
def mock_model(prompt: str) -> str:
    # In production: replace with real LLM call
    if "capital of france" in prompt.lower():
        return "The capital of France is Paris."
    elif "population" in prompt.lower() and "paris" in prompt.lower():
        return "Paris has a population of approximately 2.1 million in the city proper, and about 12 million in the greater metropolitan area."
    elif "famous landmark" in prompt.lower():
        return "Paris is famous for the Eiffel Tower, the Louvre Museum, Notre-Dame Cathedral, and the Arc de Triomphe."
    elif "eiffel tower" in prompt.lower():
        return "The Eiffel Tower was built between 1887 and 1889, designed by engineer Gustave Eiffel. It stands 330 meters tall."
    else:
        return "I understand. Could you tell me more?"

bot = SlidingWindowChatbot(mock_model, window_size=6)

# Simulate multi-turn conversation
turns = [
    "What's the capital of France?",
    "What's the population there?",
    "What are some famous landmarks in that city?",
    "Tell me more about the Eiffel Tower.",
    "When was it built?",
]

for user_input in turns:
    print(f"\nUser: {user_input}")
    response = bot.chat(user_input)
    print(f"Bot:  {response}")

print(f"\nHistory has {len(bot.get_history())} messages (max {bot.window_size})")

Output:

User: What's the capital of France?
Bot:  The capital of France is Paris.

User: What's the population there?
Bot:  Paris has a population of approximately 2.1 million in the city proper...

User: What are some famous landmarks in that city?
Bot:  Paris is famous for the Eiffel Tower, the Louvre Museum...

User: Tell me more about the Eiffel Tower.
Bot:  The Eiffel Tower was built between 1887 and 1889...

User: When was it built?
Bot:  I understand. Could you tell me more?

History has 6 messages (max 6)

The bot understands "there" (Paris) and "that city" (Paris) from context. The sliding window keeps the last 6 messages.

Strategy 2: Summary Memory

When history gets long, summarize old messages and keep recent ones in full.

class SummaryMemoryChatbot:
    def __init__(self, model_pipeline, summarizer_pipeline,
                 max_recent: int = 6, summary_threshold: int = 10,
                 system_prompt: str = "You are a helpful assistant."):
        self.model       = model_pipeline
        self.summarizer  = summarizer_pipeline
        self.max_recent  = max_recent
        self.threshold   = summary_threshold
        self.system      = system_prompt
        self.history     = []
        self.summary     = ""     # compressed memory of older turns

    def _maybe_summarize(self):
        if len(self.history) < self.threshold:
            return

        # Summarize the oldest half of history
        n_to_summarize = len(self.history) // 2
        old_messages   = self.history[:n_to_summarize]
        self.history   = self.history[n_to_summarize:]

        # Format old messages as text
        old_text = "\n".join([
            f"{m['role'].title()}: {m['content']}"
            for m in old_messages
        ])

        # Summarize (in production, call LLM to summarize)
        new_summary_input = f"{self.summary}\n\n{old_text}" if self.summary else old_text
        self.summary = self._summarize(new_summary_input)

        print(f"[Memory] Summarized {n_to_summarize} messages into summary")

    def _summarize(self, text: str) -> str:
        # In production: call LLM with a summarization prompt
        # Here: mock it
        return f"[Summary of earlier conversation: The user asked about France, Paris, its population (~2.1M), and Paris landmarks including the Eiffel Tower.]"

    def _format_prompt(self) -> str:
        parts = [f"System: {self.system}\n"]

        if self.summary:
            parts.append(f"[Earlier conversation summary]: {self.summary}\n")

        for msg in self.history[-self.max_recent:]:
            role = "Human" if msg['role'] == 'user' else "Assistant"
            parts.append(f"{role}: {msg['content']}")

        parts.append("Assistant:")
        return "\n".join(parts)

    def chat(self, user_message: str) -> str:
        self.history.append({'role': 'user', 'content': user_message})
        self._maybe_summarize()

        prompt   = self._format_prompt()
        response = self.model(prompt)
        self.history.append({'role': 'assistant', 'content': response})

        return response

    def memory_status(self):
        print(f"Summary: {'yes' if self.summary else 'none'}")
        print(f"Recent messages in full: {min(len(self.history), self.max_recent)}")
        print(f"Total history: {len(self.history)}")

summary_bot = SummaryMemoryChatbot(mock_model, None, max_recent=6, summary_threshold=8)

for user_input in turns * 2:  # repeat to trigger summarization
    response = summary_bot.chat(user_input)

summary_bot.memory_status()

Strategy 3: Entity Memory

Extract and store specific facts about the user or conversation entities.

import re
from typing import Dict

class EntityMemoryChatbot:
    def __init__(self, model_pipeline,
                 system_prompt: str = "You are a helpful assistant."):
        self.model   = model_pipeline
        self.system  = system_prompt
        self.history = []
        self.entities: Dict[str, str] = {}   # entity store

    def _extract_entities(self, message: str):
        # Simplified entity extraction (in production: use NER model or LLM)
        patterns = {
            'name':     r"(?:my name is|I am|I'm)\s+([A-Z][a-z]+)",
            'location': r"(?:I live in|I'm from|I'm in)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)",
            'job':      r"(?:I am a|I work as a|I'm a)\s+([a-z]+(?:\s+[a-z]+)?)",
            'topic':    r"(?:I want to learn about|I'm studying|I need help with)\s+([a-z\s]+)"
        }

        for entity_type, pattern in patterns.items():
            match = re.search(pattern, message, re.IGNORECASE)
            if match:
                self.entities[entity_type] = match.group(1).strip()

    def _build_entity_context(self) -> str:
        if not self.entities:
            return ""
        lines = ["Known facts about the user:"]
        for entity, value in self.entities.items():
            lines.append(f"  - {entity}: {value}")
        return "\n".join(lines)

    def _format_prompt(self) -> str:
        parts = [f"System: {self.system}"]

        entity_ctx = self._build_entity_context()
        if entity_ctx:
            parts.append(entity_ctx)

        for msg in self.history[-8:]:
            role = "Human" if msg['role'] == 'user' else "Assistant"
            parts.append(f"{role}: {msg['content']}")

        parts.append("Assistant:")
        return "\n".join(parts)

    def chat(self, user_message: str) -> str:
        self._extract_entities(user_message)
        self.history.append({'role': 'user', 'content': user_message})

        prompt   = self._format_prompt()
        response = self.model(prompt)
        self.history.append({'role': 'assistant', 'content': response})

        return response

# Test entity memory
def entity_mock_model(prompt: str) -> str:
    if "name" in prompt.lower() and "Alex" in prompt:
        return "Nice to meet you, Alex!"
    elif "Alex" in prompt and "recommend" in prompt.lower():
        return "Based on your interest in machine learning, Alex, I'd recommend starting with Python and scikit-learn."
    elif "course" in prompt.lower():
        return "For machine learning, the Andrew Ng Coursera course is excellent for beginners."
    else:
        return "Tell me more about what you'd like to learn."

entity_bot = EntityMemoryChatbot(entity_mock_model)

conversations = [
    "Hi, my name is Alex.",
    "I want to learn about machine learning.",
    "Can you recommend something?",
    "Are there any courses?",
]

for user_input in conversations:
    print(f"\nUser: {user_input}")
    response = entity_bot.chat(user_input)
    print(f"Bot:  {response}")

print(f"\nExtracted entities: {entity_bot.entities}")

Output:

User: Hi, my name is Alex.
Bot:  Nice to meet you, Alex!

User: I want to learn about machine learning.
Bot:  Tell me more about what you'd like to learn.

User: Can you recommend something?
Bot:  Based on your interest in machine learning, Alex, I'd recommend starting with Python and scikit-learn.

User: Are there any courses?
Bot:  For machine learning, the Andrew Ng Coursera course is excellent for beginners.

Extracted entities: {'name': 'Alex', 'topic': 'machine learning'}

The bot remembers the user's name and topic across all turns.

Full Chatbot With the OpenAI API

import openai
import json
from datetime import datetime

class ProductionChatbot:
    def __init__(
        self,
        system_prompt: str = "You are a helpful AI assistant.",
        model: str = "gpt-3.5-turbo",
        max_history: int = 20,
        max_tokens: int = 500,
        temperature: float = 0.7
    ):
        self.client      = openai.OpenAI()
        self.model       = model
        self.max_history = max_history
        self.max_tokens  = max_tokens
        self.temperature = temperature
        self.history     = []
        self.system      = system_prompt
        self.created_at  = datetime.now()

    def chat(self, user_message: str) -> str:
        self.history.append({'role': 'user', 'content': user_message})

        # Trim history if too long
        if len(self.history) > self.max_history:
            self.history = self.history[-self.max_history:]

        # Build message list for API
        messages = [
            {'role': 'system', 'content': self.system}
        ] + self.history

        # Call API
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            max_tokens=self.max_tokens,
            temperature=self.temperature,
        )

        assistant_message = response.choices[0].message.content
        self.history.append({'role': 'assistant', 'content': assistant_message})

        return assistant_message

    def save_conversation(self, filepath: str):
        data = {
            'created_at': self.created_at.isoformat(),
            'saved_at':   datetime.now().isoformat(),
            'model':      self.model,
            'system':     self.system,
            'messages':   self.history
        }
        with open(filepath, 'w') as f:
            json.dump(data, f, indent=2)
        print(f"Saved {len(self.history)} messages to {filepath}")

    def load_conversation(self, filepath: str):
        with open(filepath, 'r') as f:
            data = json.load(f)
        self.history = data['messages']
        self.system  = data.get('system', self.system)
        print(f"Loaded {len(self.history)} messages from {filepath}")

    def reset(self):
        self.history = []
        print("Conversation reset.")

    def get_stats(self) -> dict:
        n_user      = sum(1 for m in self.history if m['role'] == 'user')
        n_assistant = sum(1 for m in self.history if m['role'] == 'assistant')
        total_chars = sum(len(m['content']) for m in self.history)

        return {
            'turns':            n_user,
            'total_messages':   len(self.history),
            'estimated_tokens': total_chars // 4,
            'history_depth':    len(self.history)
        }

# Usage
# bot = ProductionChatbot(
#     system_prompt="You are a helpful ML tutor specializing in practical examples.",
#     model="gpt-3.5-turbo",
#     max_history=20
# )
# response = bot.chat("Explain overfitting to me.")
# print(response)
# bot.save_conversation('session_001.json')
print("ProductionChatbot ready (requires OPENAI_API_KEY)")

LangChain Memory: The Easy Way

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory
from langchain.chains import ConversationChain
from langchain_community.llms import HuggingFacePipeline
from transformers import pipeline as hf_pipeline

# Create LLM
gen_pipe = hf_pipeline('text-generation', model='gpt2', max_new_tokens=100)
llm = HuggingFacePipeline(pipeline=gen_pipe)

# Buffer memory: keeps all messages
buffer_memory = ConversationBufferMemory()

# Summary memory: automatically summarizes when too long
# summary_memory = ConversationSummaryMemory(llm=llm)

# Build conversation chain
conversation = ConversationChain(
    llm=llm,
    memory=buffer_memory,
    verbose=False
)

# Chat
result = conversation.predict(input="Hello, my name is Alex.")
print(f"Bot: {result[:100]}...")

result = conversation.predict(input="What is my name?")
print(f"Bot: {result[:100]}...")

# Inspect memory
print(f"\nMemory buffer:\n{buffer_memory.buffer}")

Persisting Memory Across Sessions

import json
import os

class PersistentChatbot:
    def __init__(self, model_pipeline, session_id: str,
                 storage_dir: str = './chat_sessions',
                 max_history: int = 50):
        self.model       = model_pipeline
        self.session_id  = session_id
        self.storage_dir = storage_dir
        self.max_history = max_history
        self.history     = []
        self.metadata    = {}

        os.makedirs(storage_dir, exist_ok=True)
        self._load_session()

    def _session_path(self) -> str:
        return os.path.join(self.storage_dir, f"{self.session_id}.json")

    def _load_session(self):
        path = self._session_path()
        if os.path.exists(path):
            with open(path, 'r') as f:
                data = json.load(f)
            self.history  = data.get('history', [])
            self.metadata = data.get('metadata', {})
            print(f"Loaded session '{self.session_id}' with {len(self.history)} messages")
        else:
            print(f"New session '{self.session_id}' started")

    def _save_session(self):
        data = {
            'session_id':   self.session_id,
            'last_updated': datetime.now().isoformat(),
            'history':      self.history,
            'metadata':     self.metadata
        }
        with open(self._session_path(), 'w') as f:
            json.dump(data, f, indent=2)

    def chat(self, user_message: str) -> str:
        self.history.append({'role': 'user', 'content': user_message})

        if len(self.history) > self.max_history:
            self.history = self.history[-self.max_history:]

        response = self.model(self._format_prompt())
        self.history.append({'role': 'assistant', 'content': response})
        self._save_session()

        return response

    def _format_prompt(self) -> str:
        parts = []
        for msg in self.history[-10:]:
            role = "Human" if msg['role'] == 'user' else "Assistant"
            parts.append(f"{role}: {msg['content']}")
        parts.append("Assistant:")
        return "\n".join(parts)

    def list_sessions(self) -> list:
        sessions = []
        for f in os.listdir(self.storage_dir):
            if f.endswith('.json'):
                sessions.append(f.replace('.json', ''))
        return sessions

# Usage
persistent_bot = PersistentChatbot(mock_model, session_id='user_alex_001')
persistent_bot.chat("What's the capital of France?")
persistent_bot.chat("What's the population there?")

print(f"\nSaved sessions: {persistent_bot.list_sessions()}")
print(f"History length: {len(persistent_bot.history)} messages")

Chatbot Quality Checklist

checklist = {
    "Memory management": [
        "Does the bot remember context from 5+ turns ago?",
        "Does it handle coreferences correctly? ('there', 'it', 'they')",
        "Does it avoid repeating information the user already gave?"
    ],
    "Context window": [
        "Does it handle very long conversations without breaking?",
        "Is there a graceful fallback when history is too long?",
        "Are summarized messages accurate and not lossy?"
    ],
    "Conversation quality": [
        "Does it stay on topic through the conversation?",
        "Does it refer to earlier decisions correctly?",
        "Does it handle topic switches gracefully?"
    ],
    "Persistence": [
        "Does it save conversations for later use?",
        "Can it resume from a previous session?",
        "Is the storage format readable and debuggable?"
    ],
    "Edge cases": [
        "What happens if the user asks about something not in memory?",
        "What happens if the user contradicts themselves?",
        "Does it handle very short or very long user messages?"
    ]
}

for category, items in checklist.items():
    print(f"\n{category}:")
    for item in items:
        print(f"  [ ] {item}")

Quick Cheat Sheet

Memory type	When to use	How it works
Buffer (all history)	Short conversations	Keep all messages, pass everything
Sliding window	Medium conversations	Keep last N messages only
Summary memory	Long conversations	Summarize old messages, keep recent in full
Entity memory	User-specific facts	Extract and store named entities
Persistent memory	Multi-session chatbots	Save/load from disk or database

Pattern	Code
Add to history	`history.append({'role': 'user', 'content': msg})`
Trim history	`history = history[-max_size:]`
Build messages	`[{'role': 'system', 'content': system}] + history`
Save session	`json.dump({'history': history}, f)`
Load session	`history = json.load(f)['history']`
LangChain buffer	`ConversationBufferMemory()`
LangChain summary	`ConversationSummaryMemory(llm=llm)`

Practice Challenges

Level 1:
Build a SlidingWindowChatbot that talks to GPT-2 locally. Have a 10-turn conversation about a topic of your choice. Print the full history at the end. Verify the bot correctly references things from earlier turns.

Level 2:
Implement SummaryMemoryChatbot with a real summarization call. After every 8 turns, summarize the first half using a small T5 model. Test with a 20-turn conversation. Print the summary after it triggers. Is the summary accurate?

Level 3:
Build PersistentChatbot that stores conversations to disk. Start a conversation, close it, restart the program, load the session, and continue the conversation. Verify the bot remembers what was said in the previous session. Add a /history command that prints a summary of previous sessions.

References

Final post, Post 100: OpenAI API: Build With GPT-4. API setup, chat completions, function calling, streaming, and cost management. The last post in the series wraps everything together.

100. OpenAI API: Build With GPT-4 (Post 100: The Final Chapter)

Akhilesh — Thu, 28 May 2026 05:08:19 +0000

Post 1 was Python variables.

Post 100 is GPT-4.

You've come from writing your first for loop to understanding transformer architectures, building neural networks from scratch, fine-tuning LLMs with LoRA, building RAG pipelines, and creating chatbots with memory.

This final post puts it all together. The OpenAI API is how most people actually ship AI products. Chat completions, function calling, streaming, vision, embeddings. Everything you need to build something real.

Let's finish strong.

What You'll Learn Here

API setup and authentication
Chat completions: the core pattern
System prompts: controlling model behavior
Function calling: giving LLMs tools
Streaming: responses that appear word by word
Vision: analyzing images with GPT-4V
Embeddings via API: fast, high quality
Token counting and cost management
Rate limits and error handling
A complete project: an AI assistant with tools

Setup

pip install openai tiktoken

import openai
import os

# Set your API key
# Option 1: environment variable (recommended)
# export OPENAI_API_KEY='sk-...'

# Option 2: set directly (never commit this to git)
# openai.api_key = 'sk-...'

client = openai.OpenAI()  # reads OPENAI_API_KEY from environment

# Test the connection
models = client.models.list()
print("Connected to OpenAI API")
print(f"Available models (sample): {[m.id for m in list(models)[:5]]}")

Chat Completions: The Core Pattern

Every interaction with GPT-4 goes through the same API call. Messages are a list of role-content pairs: system, user, and assistant.

# Simplest possible call
response = client.chat.completions.create(
    model="gpt-4o-mini",   # fast and cheap for most tasks
    messages=[
        {"role": "user", "content": "What is machine learning in one sentence?"}
    ]
)

print(response.choices[0].message.content)
print(f"\nTokens used: {response.usage.total_tokens}")
print(f"Model: {response.model}")

Output:

Machine learning is a field of AI where computers learn patterns from data to make predictions or decisions without being explicitly programmed for each task.

Tokens used: 52
Model: gpt-4o-mini

# With system prompt and multiple turns
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "You are a senior ML engineer who explains concepts clearly and concisely. Use analogies when helpful. Never use jargon without explaining it."
        },
        {
            "role": "user",
            "content": "Explain overfitting."
        }
    ],
    temperature=0.7,        # creativity (0=deterministic, 2=very random)
    max_tokens=300,         # cap the response length
    top_p=0.95,             # nucleus sampling
    frequency_penalty=0.1,  # penalize repeated tokens
    presence_penalty=0.1,   # penalize already-mentioned topics
)

print(response.choices[0].message.content)

System Prompts: Controlling Model Behavior

The system prompt is the single most powerful tool for shaping GPT-4's behavior.

system_prompts = {
    "concise_explainer": """
You explain technical concepts in 3 sentences or less.
Always use a concrete real-world example.
Never use bullet points.
""",
    "code_reviewer": """
You are a senior Python engineer doing code review.
Point out bugs, style issues, and performance problems.
Format your response as:
BUGS: (list any bugs)
STYLE: (list style issues)
PERFORMANCE: (list performance concerns)
SUGGESTIONS: (overall recommendation)
""",
    "socratic_tutor": """
You are a Socratic tutor. Never give direct answers.
Instead, guide the student with questions that help them discover the answer themselves.
When they get something right, affirm it and ask a deeper follow-up question.
""",
    "strict_json": """
You always respond in valid JSON format only.
No markdown. No explanation. Just raw JSON.
Never include anything outside the JSON structure.
"""
}

# Test the code reviewer persona
code_to_review = """
def get_user_data(user_ids):
    results = []
    for id in user_ids:
        data = database.query(f"SELECT * FROM users WHERE id = {id}")
        results.append(data)
    return results
"""

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system",  "content": system_prompts["code_reviewer"]},
        {"role": "user",    "content": f"Review this code:\n```
{% endraw %}
python{code_to_review}
{% raw %}
```"}
    ]
)
print(response.choices[0].message.content)

Structured Output: JSON Mode

When you need JSON responses you can parse reliably.

import json

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "Extract structured information from the text. Return JSON only."
        },
        {
            "role": "user",
            "content": """
Extract the following from this text:
- person_name
- job_title
- company
- key_skills (list)

Text: "Sarah Chen is a Senior ML Engineer at Anthropic. She specializes in 
transformer architectures, reinforcement learning from human feedback, and 
large-scale distributed training."
"""
        }
    ],
    response_format={"type": "json_object"}   # forces JSON output
)

data = json.loads(response.choices[0].message.content)
print(json.dumps(data, indent=2))

Output:

{
  "person_name": "Sarah Chen",
  "job_title": "Senior ML Engineer",
  "company": "Anthropic",
  "key_skills": [
    "transformer architectures",
    "reinforcement learning from human feedback",
    "large-scale distributed training"
  ]
}

Function Calling: Giving GPT-4 Tools

Function calling lets the model request tools (functions) that you define. The model decides when to call a function and with what arguments. You execute it and send results back.

This is how AI agents work.

import json

# Define tools the model can use
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g. 'London' or 'Tokyo'"
                    },
                    "units": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature units"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_documents",
            "description": "Search the company knowledge base for relevant documents",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    },
                    "max_results": {
                        "type": "integer",
                        "description": "Maximum number of results to return",
                        "default": 3
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Mock function implementations
def get_weather(city: str, units: str = "celsius") -> dict:
    # In production: call a real weather API
    return {
        "city": city,
        "temperature": 18,
        "units": units,
        "condition": "partly cloudy",
        "humidity": "65%"
    }

def search_documents(query: str, max_results: int = 3) -> list:
    # In production: call your vector database
    return [
        {"title": f"Document about {query}", "snippet": f"Relevant content for: {query}", "score": 0.92},
        {"title": f"Guide to {query}", "snippet": f"Comprehensive overview of {query}", "score": 0.87},
    ][:max_results]

# Dispatch function calls
def execute_function(name: str, arguments: dict):
    if name == "get_weather":
        return get_weather(**arguments)
    elif name == "search_documents":
        return search_documents(**arguments)
    else:
        return {"error": f"Unknown function: {name}"}

# Full function calling loop
def agent_chat(user_message: str) -> str:
    messages = [
        {"role": "system",  "content": "You are a helpful assistant with access to weather data and a document search tool. Use tools when needed."},
        {"role": "user",    "content": user_message}
    ]

    while True:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"   # model decides when to use tools
        )

        message = response.choices[0].message

        # If no tool calls: we have the final answer
        if not message.tool_calls:
            return message.content

        # Process tool calls
        messages.append(message)   # add assistant message with tool_calls

        for tool_call in message.tool_calls:
            function_name = tool_call.function.name
            arguments     = json.loads(tool_call.function.arguments)

            print(f"  [Tool call] {function_name}({arguments})")

            result = execute_function(function_name, arguments)

            messages.append({
                "role":         "tool",
                "tool_call_id": tool_call.id,
                "content":      json.dumps(result)
            })

# Test it
queries = [
    "What's the weather like in Tokyo right now?",
    "Search for documents about machine learning best practices.",
    "What's the weather in Paris and London? Compare them.",
]

for query in queries:
    print(f"\nUser: {query}")
    answer = agent_chat(query)
    print(f"Bot:  {answer}")

Output:

User: What's the weather like in Tokyo right now?
  [Tool call] get_weather({'city': 'Tokyo', 'units': 'celsius'})
Bot:  The current weather in Tokyo is 18°C and partly cloudy, with humidity at 65%.

User: Search for documents about machine learning best practices.
  [Tool call] search_documents({'query': 'machine learning best practices', 'max_results': 3})
Bot:  I found 2 relevant documents about machine learning best practices...

User: What's the weather in Paris and London? Compare them.
  [Tool call] get_weather({'city': 'Paris', 'units': 'celsius'})
  [Tool call] get_weather({'city': 'London', 'units': 'celsius'})
Bot:  Both Paris and London currently show 18°C with partly cloudy conditions...

Streaming: Word-by-Word Responses

Instead of waiting for the full response, stream it token by token. Makes the UI feel much faster.

import sys

def stream_response(user_message: str, system: str = "You are a helpful assistant."):
    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system},
            {"role": "user",   "content": user_message}
        ],
        stream=True   # enable streaming
    )

    full_response = ""
    print("Bot: ", end="", flush=True)

    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            token = chunk.choices[0].delta.content
            print(token, end="", flush=True)
            full_response += token

    print()   # newline at end
    return full_response

response = stream_response("Explain gradient descent in 3 sentences.")

Vision: Analyze Images With GPT-4V

import base64
from pathlib import Path

def encode_image(image_path: str) -> str:
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

def analyze_image(image_path: str, question: str) -> str:
    base64_image = encode_image(image_path)

    response = client.chat.completions.create(
        model="gpt-4o",   # vision requires gpt-4o or gpt-4-vision-preview
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}",
                            "detail": "high"   # or "low" for faster/cheaper
                        }
                    },
                    {
                        "type": "text",
                        "text": question
                    }
                ]
            }
        ],
        max_tokens=300
    )

    return response.choices[0].message.content

# Also works with image URLs directly
def analyze_image_url(url: str, question: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": url}},
                    {"type": "text",      "text": question}
                ]
            }
        ]
    )
    return response.choices[0].message.content

# Example
# result = analyze_image_url(
#     "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1e/Eiffel_Tower.jpg/640px-Eiffel_Tower.jpg",
#     "What is in this image? Describe it in detail."
# )
print("Vision API ready - pass an image path or URL with your question")

Embeddings via API

# High-quality embeddings from OpenAI
def get_embedding(text: str, model: str = "text-embedding-3-small") -> list:
    response = client.embeddings.create(
        input=text,
        model=model
    )
    return response.data[0].embedding

def get_embeddings_batch(texts: list, model: str = "text-embedding-3-small") -> list:
    response = client.embeddings.create(
        input=texts,
        model=model
    )
    return [item.embedding for item in response.data]

# Available embedding models
embedding_models = {
    "text-embedding-3-small": {"dim": 1536, "cost": "$0.02/1M tokens", "quality": "good"},
    "text-embedding-3-large": {"dim": 3072, "cost": "$0.13/1M tokens", "quality": "best"},
    "text-embedding-ada-002": {"dim": 1536, "cost": "$0.10/1M tokens", "quality": "older"},
}

print("OpenAI Embedding Models:")
for model, info in embedding_models.items():
    print(f"  {model}: dim={info['dim']}, cost={info['cost']}, quality={info['quality']}")

# Example usage
# embedding = get_embedding("Machine learning is fascinating.")
# print(f"Embedding dimension: {len(embedding)}")

Token Counting and Cost Management

import tiktoken

def count_tokens(text: str, model: str = "gpt-4o-mini") -> int:
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        encoding = tiktoken.get_encoding("cl100k_base")
    return len(encoding.encode(text))

def count_message_tokens(messages: list, model: str = "gpt-4o-mini") -> int:
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        encoding = tiktoken.get_encoding("cl100k_base")

    tokens_per_message = 3   # every message has role + content overhead
    tokens_per_name    = 1

    total = 0
    for message in messages:
        total += tokens_per_message
        for key, value in message.items():
            total += len(encoding.encode(str(value)))
            if key == "name":
                total += tokens_per_name

    total += 3   # every reply primed with <|start|>assistant<|message|>
    return total

# Pricing (as of 2024, check openai.com/pricing for current rates)
pricing = {
    "gpt-4o":           {"input": 5.00,  "output": 15.00},   # per 1M tokens
    "gpt-4o-mini":      {"input": 0.15,  "output": 0.60},
    "gpt-3.5-turbo":    {"input": 0.50,  "output": 1.50},
    "text-embedding-3-small": {"input": 0.02, "output": 0},
}

def estimate_cost(n_input_tokens: int, n_output_tokens: int, model: str) -> float:
    if model not in pricing:
        return 0
    p        = pricing[model]
    cost_in  = (n_input_tokens / 1_000_000) * p["input"]
    cost_out = (n_output_tokens / 1_000_000) * p["output"]
    return cost_in + cost_out

# Example: estimate cost before making a call
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user",   "content": "Explain transformer architecture in detail."}
]
model = "gpt-4o-mini"

input_tokens     = count_message_tokens(messages, model)
estimated_output = 300   # estimate based on max_tokens

cost = estimate_cost(input_tokens, estimated_output, model)

print(f"Input tokens:    {input_tokens}")
print(f"Estimated output: {estimated_output}")
print(f"Estimated cost:  ${cost:.6f}")

# Track actual usage across calls
class UsageTracker:
    def __init__(self):
        self.total_input_tokens  = 0
        self.total_output_tokens = 0
        self.total_calls         = 0
        self.model_usage         = {}

    def track(self, response, model: str):
        usage = response.usage
        self.total_input_tokens  += usage.prompt_tokens
        self.total_output_tokens += usage.completion_tokens
        self.total_calls         += 1

        if model not in self.model_usage:
            self.model_usage[model] = {'input': 0, 'output': 0, 'calls': 0}
        self.model_usage[model]['input']  += usage.prompt_tokens
        self.model_usage[model]['output'] += usage.completion_tokens
        self.model_usage[model]['calls']  += 1

    def report(self):
        print(f"Total API calls:    {self.total_calls}")
        print(f"Total input tokens: {self.total_input_tokens:,}")
        print(f"Total output tokens:{self.total_output_tokens:,}")
        total_cost = sum(
            estimate_cost(info['input'], info['output'], model)
            for model, info in self.model_usage.items()
        )
        print(f"Estimated cost:     ${total_cost:.4f}")

tracker = UsageTracker()

Error Handling and Rate Limits

import time
import random
from openai import RateLimitError, APIError, APIConnectionError

def robust_api_call(messages: list, model: str = "gpt-4o-mini",
                    max_retries: int = 3, **kwargs) -> str:
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                **kwargs
            )
            return response.choices[0].message.content

        except RateLimitError as e:
            if attempt < max_retries - 1:
                wait_time = (2 ** attempt) + random.uniform(0, 1)
                print(f"Rate limited. Retrying in {wait_time:.1f}s...")
                time.sleep(wait_time)
            else:
                raise

        except APIConnectionError as e:
            if attempt < max_retries - 1:
                print(f"Connection error. Retrying... ({attempt+1}/{max_retries})")
                time.sleep(2)
            else:
                raise

        except APIError as e:
            if e.status_code == 500 and attempt < max_retries - 1:
                print(f"Server error. Retrying...")
                time.sleep(1)
            else:
                raise

    raise Exception("Max retries exceeded")

# Usage
# result = robust_api_call(
#     messages=[{"role": "user", "content": "Hello"}],
#     model="gpt-4o-mini",
#     temperature=0.7
# )
print("Robust API call function ready with exponential backoff")

Complete Project: An AI Assistant With Tools and Memory

Bringing it all together. A production-ready assistant that remembers, uses tools, and handles errors.

import json
import time
from typing import List, Optional
from collections import deque

class AIAssistant:
    def __init__(
        self,
        name: str = "Assistant",
        system_prompt: str = "You are a helpful AI assistant.",
        model: str = "gpt-4o-mini",
        max_history: int = 20,
        tools: Optional[list] = None,
        temperature: float = 0.7
    ):
        self.client      = openai.OpenAI()
        self.name        = name
        self.model       = model
        self.temperature = temperature
        self.tools       = tools or []
        self.history     = deque(maxlen=max_history)
        self.system      = system_prompt
        self.usage       = {"calls": 0, "tokens": 0}

    def _get_messages(self) -> list:
        return [{"role": "system", "content": self.system}] + list(self.history)

    def _execute_tool(self, name: str, args: dict) -> str:
        # Override this method to add your own tools
        return json.dumps({"error": f"Tool '{name}' not implemented"})

    def chat(self, user_message: str, stream: bool = False) -> str:
        self.history.append({"role": "user", "content": user_message})

        kwargs = {
            "model":       self.model,
            "messages":    self._get_messages(),
            "temperature": self.temperature,
        }
        if self.tools:
            kwargs["tools"]        = self.tools
            kwargs["tool_choice"]  = "auto"
        if stream:
            kwargs["stream"] = True

        # Handle function calling loop
        while True:
            if stream and not self.tools:
                # Stream without tools
                response_text = ""
                stream_resp   = self.client.chat.completions.create(**kwargs)
                print(f"{self.name}: ", end="", flush=True)
                for chunk in stream_resp:
                    if chunk.choices[0].delta.content:
                        token = chunk.choices[0].delta.content
                        print(token, end="", flush=True)
                        response_text += token
                print()
                self.history.append({"role": "assistant", "content": response_text})
                return response_text

            # Non-streaming or tools
            response = self.client.chat.completions.create(**kwargs)
            message  = response.choices[0].message

            self.usage["calls"]  += 1
            self.usage["tokens"] += response.usage.total_tokens

            if not message.tool_calls:
                self.history.append({"role": "assistant", "content": message.content})
                return message.content

            # Process tool calls
            self.history.append(message)
            kwargs["messages"] = self._get_messages()

            for tool_call in message.tool_calls:
                fn_name = tool_call.function.name
                fn_args = json.loads(tool_call.function.arguments)

                result = self._execute_tool(fn_name, fn_args)

                self.history.append({
                    "role":         "tool",
                    "tool_call_id": tool_call.id,
                    "content":      result
                })

            kwargs["messages"] = self._get_messages()

    def summarize_history(self) -> str:
        if not self.history:
            return "No conversation history."

        summary_prompt = f"Summarize this conversation in 2-3 sentences:\n\n"
        for msg in self.history:
            if isinstance(msg, dict) and msg.get('role') in ['user', 'assistant']:
                role = msg['role'].title()
                content = msg.get('content', '')
                if content:
                    summary_prompt += f"{role}: {content[:100]}...\n"

        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": summary_prompt}],
            max_tokens=150
        )
        return response.choices[0].message.content

    def clear(self):
        self.history.clear()

    def stats(self) -> dict:
        return {
            "name":    self.name,
            "model":   self.model,
            "calls":   self.usage["calls"],
            "tokens":  self.usage["tokens"],
            "history": len(self.history),
        }


# Concrete assistant with tools
class MLTutorAssistant(AIAssistant):
    def __init__(self):
        super().__init__(
            name="ML Tutor",
            system_prompt="""You are an expert ML tutor who has read 'How Machines Learn: A Complete Guide from Zero to AI Engineer'.
You teach clearly with concrete examples and code snippets.
You remember what the student has learned so far in this session.
When relevant, reference concepts from earlier in the conversation.""",
            model="gpt-4o-mini",
            max_history=20,
            tools=[
                {
                    "type": "function",
                    "function": {
                        "name": "get_code_example",
                        "description": "Get a working Python code example for an ML concept",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "concept": {"type": "string", "description": "The ML concept to get code for"},
                                "difficulty": {"type": "string", "enum": ["beginner", "intermediate", "advanced"]}
                            },
                            "required": ["concept"]
                        }
                    }
                }
            ]
        )

    def _execute_tool(self, name: str, args: dict) -> str:
        if name == "get_code_example":
            concept    = args.get("concept", "")
            difficulty = args.get("difficulty", "beginner")
            # In production: pull from a real code database
            example = {
                "concept":    concept,
                "difficulty": difficulty,
                "code": f"# Example: {concept}\nimport sklearn\n# ... working code here",
                "explanation": f"This code demonstrates {concept} at {difficulty} level."
            }
            return json.dumps(example)
        return json.dumps({"error": f"Unknown tool: {name}"})


# Demo the complete assistant
print("=" * 60)
print("ML Tutor Assistant Demo")
print("=" * 60)

tutor = MLTutorAssistant()

demo_questions = [
    "What is overfitting and how do I detect it?",
    "Can you give me a code example for that?",
    "How is this related to the bias-variance tradeoff?",
]

for question in demo_questions:
    print(f"\nStudent: {question}")
    answer = tutor.chat(question)
    print(f"Tutor: {answer[:200]}...")

print(f"\n{tutor.stats()}")

Cost Optimization Tips

cost_tips = {
    "1. Model selection": {
        "tip": "Use gpt-4o-mini for most tasks. Only upgrade to gpt-4o when quality is genuinely insufficient.",
        "saving": "95% cost reduction vs gpt-4o"
    },
    "2. Prompt caching": {
        "tip": "OpenAI automatically caches prompts > 1024 tokens. Long system prompts get cached.",
        "saving": "50% discount on cached tokens"
    },
    "3. Batch API": {
        "tip": "Use the Batch API for tasks that don't need real-time responses.",
        "saving": "50% discount vs real-time"
    },
    "4. Token counting": {
        "tip": "Count tokens before sending. Trim unnecessary context. Remove long system prompts when not needed.",
        "saving": "10-40% depending on your prompts"
    },
    "5. Max tokens": {
        "tip": "Always set max_tokens. Without it, the model can generate very long responses.",
        "saving": "Prevents runaway costs"
    },
    "6. Temperature for deterministic tasks": {
        "tip": "Use temperature=0 for classification, extraction, formatting. Deterministic = consistent = cacheable.",
        "saving": "Better cache hit rates"
    },
    "7. Local models for testing": {
        "tip": "Use Ollama or llama.cpp during development. Only hit the API when testing production behavior.",
        "saving": "90%+ during development"
    },
}

print("Cost Optimization Tips:")
for tip_name, info in cost_tips.items():
    print(f"\n{tip_name}")
    print(f"  Tip:    {info['tip']}")
    print(f"  Saving: {info['saving']}")

The Complete Journey: 100 Posts in One View

PHASE 1: Python That Actually Works (Posts 1-10)
  Variables, functions, OOP, error handling, file I/O

PHASE 2: Math for ML (Posts 11-20)
  Linear algebra, calculus, probability, statistics

PHASE 3: Data Wrangling Tools (Posts 27-39)
  NumPy, Pandas, Matplotlib, Seaborn, EDA

PHASE 4: SQL for Data (Posts 40-45)
  SELECT, JOINs, window functions, Python + SQL

PHASE 5: Dev Tools (Posts 46-50)
  Git, GitHub, Jupyter, Colab, virtual environments

PHASE 6: Machine Learning Core (Posts 51-71)
  Linear/logistic regression, trees, XGBoost, SVM,
  KNN, Naive Bayes, evaluation metrics, clustering,
  PCA, feature engineering, hyperparameter tuning

PHASE 7: Deep Learning (Posts 72-86)
  Neural networks, backprop, PyTorch, training loops,
  GPUs, CNNs, transfer learning, RNNs, autoencoders, GANs

PHASE 8: NLP and LLMs (Posts 87-100)
  Text preprocessing, tokenization, embeddings, attention,
  transformers, BERT, GPT, HuggingFace, fine-tuning,
  LoRA, vector search, RAG, chatbots, OpenAI API

What You Can Build Now

After 100 posts, you can build:

Classification systems for any domain
Regression models for prediction problems
Document intelligence pipelines with RAG
Custom chatbots with memory and tools
Image classification with CNNs
Fine-tuned domain models with LoRA
Semantic search engines
End-to-end ML pipelines with proper evaluation

The fundamentals don't change. Models come and go. APIs change. Architectures evolve. But gradient descent, overfitting, precision vs recall, the training loop, attention mechanisms: these ideas will still matter in 10 years.

You now understand them. Not just how to use them. Why they work.

Quick Cheat Sheet: OpenAI API

Task	Code
Basic chat	`client.chat.completions.create(model=..., messages=[...])`
System prompt	`{"role": "system", "content": "..."}` in messages
JSON output	`response_format={"type": "json_object"}`
Function calling	`tools=[...]`, `tool_choice="auto"`
Streaming	`stream=True`, iterate over chunks
Vision	Add `{"type": "image_url", "image_url": {"url": "..."}}` to content
Embeddings	`client.embeddings.create(input=text, model="text-embedding-3-small")`
Count tokens	`tiktoken.encoding_for_model(model).encode(text)`
Cost estimate	tokens / 1M * price_per_million
Retry on error	Catch `RateLimitError`, exponential backoff

Practice Challenges

Level 1:
Build a simple Q&A bot using the OpenAI API. Give it a custom system prompt that defines a persona. Test it with 10 questions and evaluate response quality.

Level 2:
Add function calling to the assistant. Define at least two tools: one that retrieves weather and one that searches Wikipedia. Verify the model correctly decides when to call each tool.

Level 3:
Build a complete AI assistant that combines: a custom system prompt, conversation memory (sliding window), RAG (ChromaDB with 20+ documents), at least 2 function tools, streaming output, and usage/cost tracking. Deploy it as a simple command-line chatbot.

References

This Is Post 100.

You started from zero. You learned Python, math, data wrangling, machine learning, deep learning, and large language models. You built classifiers, regressors, neural networks, transformers, RAG pipelines, and chatbots.

One hundred posts. One complete journey.

The field will keep moving. New architectures will appear. Better models will ship. Benchmarks will fall. But the person who understands why things work is never left behind by what comes next.

That's you now.

Go build something.

98. RAG: Give Your AI Access to Your Documents

Akhilesh — Tue, 26 May 2026 20:23:00 +0000

You ask ChatGPT about your company's internal policies. It makes something up. It sounds confident. It's wrong.

That's the hallucination problem. LLMs generate text based on what they learned during training. If the answer wasn't in the training data, they fabricate one that sounds plausible.

RAG (Retrieval Augmented Generation) fixes this. Before generating, the system retrieves relevant documents from your own knowledge base. The LLM reads those documents and generates an answer grounded in real content.

Your documents. Your data. Accurate answers.

What You'll Learn Here

Why RAG beats fine-tuning for knowledge-heavy tasks
The complete RAG pipeline: chunk, embed, retrieve, generate
Chunking strategies that actually work
Building RAG from scratch with sentence-transformers and a local LLM
Building RAG with LangChain for real projects
Evaluating RAG: what good looks like and what breaks it
Common failure modes and how to fix them

RAG vs Fine-Tuning: When to Use Which

Both give LLMs access to new knowledge. They're solving different problems.

Fine-tuning:
  - Best for: teaching style, format, behavior
  - Updates model weights
  - Needs retraining when data changes
  - Can't cite sources easily
  - Expensive to update frequently

RAG:
  - Best for: factual knowledge, documents, databases
  - No weight updates
  - Update knowledge base anytime, instantly
  - Can cite exact source passages
  - Perfect for private or frequently changing data

Rule of thumb:
  Behavior/style change → fine-tune
  Knowledge/facts/documents → RAG
  Both → fine-tune + RAG

The Complete RAG Pipeline

1. INDEXING (done once, offline)
   Load documents
   → Split into chunks
   → Embed each chunk
   → Store in vector database

2. RETRIEVAL (done at query time)
   User sends question
   → Embed the question
   → Find top-k similar chunks
   → Return chunks as context

3. GENERATION (done at query time)
   Build prompt: question + retrieved chunks
   → Send to LLM
   → LLM generates answer grounded in chunks
   → Return answer to user

Step 1: Chunking Documents

The most underrated step. How you split documents dramatically affects retrieval quality.

import re
from typing import List

# Strategy 1: Fixed-size chunking
def chunk_fixed(text: str, chunk_size: int = 500, overlap: int = 50) -> List[str]:
    chunks = []
    start  = 0
    while start < len(text):
        end = start + chunk_size
        chunks.append(text[start:end])
        start = end - overlap   # overlap to preserve context at boundaries
    return chunks

# Strategy 2: Sentence-aware chunking (better)
def chunk_by_sentences(text: str, max_chunk_size: int = 500) -> List[str]:
    # Split on sentence boundaries
    sentences = re.split(r'(?<=[.!?])\s+', text.strip())
    chunks    = []
    current   = ""

    for sentence in sentences:
        if len(current) + len(sentence) <= max_chunk_size:
            current += " " + sentence if current else sentence
        else:
            if current:
                chunks.append(current.strip())
            current = sentence

    if current:
        chunks.append(current.strip())

    return chunks

# Strategy 3: Paragraph-aware chunking (often best for structured docs)
def chunk_by_paragraphs(text: str, max_chunk_size: int = 800) -> List[str]:
    paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
    chunks     = []
    current    = ""

    for para in paragraphs:
        if len(current) + len(para) + 2 <= max_chunk_size:
            current += "\n\n" + para if current else para
        else:
            if current:
                chunks.append(current.strip())
            current = para

    if current:
        chunks.append(current.strip())

    return chunks

# Test on sample text
sample_text = """
Machine learning is a branch of artificial intelligence that enables computers to learn from data. 
It has three main types: supervised, unsupervised, and reinforcement learning.

Supervised learning uses labeled examples where the correct answers are known. 
The model learns to map inputs to outputs by minimizing error on training data. 
Common algorithms include linear regression, decision trees, and neural networks.

Unsupervised learning finds patterns in data without labels. 
Clustering algorithms group similar examples together. 
Dimensionality reduction simplifies data while preserving structure.

Reinforcement learning trains an agent to take actions in an environment to maximize reward.
It learns through trial and error, receiving feedback from the environment.
Applications include game playing, robotics, and recommendation systems.
"""

chunks_fixed = chunk_fixed(sample_text, chunk_size=200, overlap=30)
chunks_sents = chunk_by_sentences(sample_text, max_chunk_size=300)
chunks_paras = chunk_by_paragraphs(sample_text, max_chunk_size=400)

print(f"Fixed chunks:     {len(chunks_fixed)}")
print(f"Sentence chunks:  {len(chunks_sents)}")
print(f"Paragraph chunks: {len(chunks_paras)}")

print(f"\nParagraph chunk 1:\n'{chunks_paras[0]}'")
print(f"\nParagraph chunk 2:\n'{chunks_paras[1]}'")

Output:

Fixed chunks:     7
Sentence chunks:  4
Paragraph chunks: 4

Paragraph chunk 1:
'Machine learning is a branch of artificial intelligence that enables computers to learn from data. 
It has three main types: supervised, unsupervised, and reinforcement learning.'

Paragraph chunk 2:
'Supervised learning uses labeled examples where the correct answers are known. 
The model learns to map inputs to outputs by minimizing error on training data. 
Common algorithms include linear regression, decision trees, and neural networks.'

Chunking guidelines:

Chunk size 300-600 characters works well for most use cases
Always include overlap (50-100 chars) so context isn't lost at boundaries
Paragraph chunking preserves semantic units better than fixed-size
Smaller chunks: better precision (more specific retrieval)
Larger chunks: better recall (more context per chunk)

Step 2: Building the Index

from sentence_transformers import SentenceTransformer
import chromadb
import numpy as np

# Knowledge base: a collection of ML documentation
knowledge_base = {
    'doc1.txt': """
        Linear regression predicts a continuous output variable from input features.
        It fits a straight line (or hyperplane in multiple dimensions) through the data.
        The model minimizes the mean squared error between predictions and true values.
        The learned equation is: y = w1*x1 + w2*x2 + ... + b
        Used for: house price prediction, sales forecasting, temperature prediction.
    """,
    'doc2.txt': """
        Logistic regression is used for binary classification despite its name.
        It applies a sigmoid function to the linear combination of features.
        Output is a probability between 0 and 1.
        The decision boundary is where the probability equals 0.5.
        Used for: spam detection, disease diagnosis, fraud detection.
    """,
    'doc3.txt': """
        Random forests combine many decision trees to reduce overfitting.
        Each tree is trained on a random subset of data (bagging).
        Each split considers a random subset of features.
        Final prediction is the majority vote (classification) or average (regression).
        Feature importance can be extracted from the forest.
    """,
    'doc4.txt': """
        XGBoost builds trees sequentially, each one correcting errors from the previous.
        It uses gradient boosting with regularization to prevent overfitting.
        Learning rate controls how much each tree contributes.
        Early stopping prevents overtraining.
        Dominates Kaggle competitions on tabular data.
    """,
    'doc5.txt': """
        Cross-validation gives a reliable estimate of model performance.
        K-fold CV splits data into k equal parts, trains on k-1, tests on 1.
        This is repeated k times with different test sets.
        Average score across folds is the final estimate.
        Prevents optimistic bias from a single train/test split.
    """,
    'doc6.txt': """
        The confusion matrix shows all four prediction outcomes.
        True positives: correctly predicted positive.
        True negatives: correctly predicted negative.
        False positives: incorrectly predicted positive (Type I error).
        False negatives: incorrectly predicted negative (Type II error).
        Precision = TP / (TP + FP). Recall = TP / (TP + FN).
    """,
    'doc7.txt': """
        Overfitting occurs when a model performs well on training data but poorly on test data.
        Signs: large gap between train and validation accuracy.
        Causes: model too complex, too little data, training too long.
        Fixes: regularization, dropout, more data, early stopping, simpler model.
        The bias-variance tradeoff describes the fundamental tension.
    """,
    'doc8.txt': """
        Transformers use self-attention to process sequences in parallel.
        Self-attention computes relationships between all token pairs simultaneously.
        Multi-head attention runs several attention operations in parallel.
        Positional encoding adds position information to token embeddings.
        Layer normalization and residual connections stabilize training.
    """,
}

class RAGIndexer:
    def __init__(self, model_name='sentence-transformers/all-MiniLM-L6-v2'):
        self.model       = SentenceTransformer(model_name)
        self.chroma      = chromadb.Client()
        self.collection  = self.chroma.create_collection(
            name='rag_knowledge_base',
            metadata={'hnsw:space': 'cosine'}
        )

    def index_documents(self, documents: dict, chunk_size: int = 400):
        all_chunks = []
        all_ids    = []
        all_meta   = []

        for doc_name, content in documents.items():
            chunks = chunk_by_sentences(content, max_chunk_size=chunk_size)
            for i, chunk in enumerate(chunks):
                if len(chunk.strip()) < 30:   # skip tiny chunks
                    continue
                chunk_id = f"{doc_name}_chunk{i}"
                all_chunks.append(chunk.strip())
                all_ids.append(chunk_id)
                all_meta.append({'source': doc_name, 'chunk_idx': i})

        if not all_chunks:
            return

        # Encode all chunks
        print(f"Encoding {len(all_chunks)} chunks...")
        embeddings = self.model.encode(all_chunks, show_progress_bar=False)

        # Add to ChromaDB
        self.collection.add(
            ids        = all_ids,
            documents  = all_chunks,
            embeddings = [e.tolist() for e in embeddings],
            metadatas  = all_meta
        )
        print(f"Indexed {len(all_chunks)} chunks from {len(documents)} documents")

    def retrieve(self, query: str, top_k: int = 3) -> List[dict]:
        query_embedding = self.model.encode([query])[0].tolist()

        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k
        )

        retrieved = []
        for doc, meta, dist in zip(
            results['documents'][0],
            results['metadatas'][0],
            results['distances'][0]
        ):
            retrieved.append({
                'text':       doc,
                'source':     meta['source'],
                'similarity': 1 - dist   # ChromaDB returns distance, not similarity
            })

        return retrieved

# Build the index
indexer = RAGIndexer()
indexer.index_documents(knowledge_base)

# Test retrieval
query   = "How do I prevent a model from overfitting?"
results = indexer.retrieve(query, top_k=3)

print(f"\nQuery: '{query}'")
print("-" * 60)
for i, r in enumerate(results):
    print(f"\n{i+1}. [{r['similarity']:.3f}] From: {r['source']}")
    print(f"   {r['text'][:150]}...")

Output:

Indexed 16 chunks from 8 documents

Query: 'How do I prevent a model from overfitting?'
------------------------------------------------------------

1. [0.712] From: doc7.txt
   Overfitting occurs when a model performs well on training data but poorly on test data...

2. [0.531] From: doc4.txt
   XGBoost builds trees sequentially, each one correcting errors from the previous...

3. [0.489] From: doc3.txt
   Random forests combine many decision trees to reduce overfitting...

Step 3: Generation With Retrieved Context

# Using a local model via HuggingFace Transformers
from transformers import pipeline

# For a real project: use 'google/flan-t5-base' or connect to OpenAI API
generator = pipeline(
    'text2text-generation',
    model='google/flan-t5-base',
    max_new_tokens=200
)

def build_rag_prompt(question: str, context_chunks: List[dict]) -> str:
    context = "\n\n".join([
        f"[Source: {c['source']}]\n{c['text']}"
        for c in context_chunks
    ])

    prompt = f"""Answer the question based only on the provided context.
If the context doesn't contain enough information, say "I don't have enough information to answer this."

Context:
{context}

Question: {question}

Answer:"""

    return prompt

class RAGPipeline:
    def __init__(self, indexer: RAGIndexer, generator_pipeline):
        self.indexer   = indexer
        self.generator = generator_pipeline

    def answer(self, question: str, top_k: int = 3, verbose: bool = False) -> dict:
        # Step 1: Retrieve relevant chunks
        chunks = self.indexer.retrieve(question, top_k=top_k)

        # Step 2: Build prompt
        prompt = build_rag_prompt(question, chunks)

        if verbose:
            print("=== RETRIEVED CONTEXT ===")
            for c in chunks:
                print(f"[{c['source']}] sim={c['similarity']:.3f}: {c['text'][:100]}...")
            print("\n=== PROMPT ===")
            print(prompt[:500] + "...")

        # Step 3: Generate answer
        result = self.generator(prompt)[0]['generated_text']

        return {
            'question': question,
            'answer':   result.strip(),
            'sources':  [c['source'] for c in chunks],
            'chunks':   chunks
        }

# Build the RAG pipeline
rag = RAGPipeline(indexer, generator)

# Ask questions
questions = [
    "What causes overfitting and how do I fix it?",
    "How is precision different from recall?",
    "What makes XGBoost good for competitions?",
    "How do transformers process sequences?",
]

for question in questions:
    result = rag.answer(question)
    print(f"\nQ: {question}")
    print(f"A: {result['answer']}")
    print(f"Sources: {result['sources']}")
    print("-" * 60)

Using the OpenAI API for Better Generation

For production quality, use a real LLM API. The retrieval stays the same. Only the generation step changes.

# Replace the generator with OpenAI API
# pip install openai

import openai

def generate_with_openai(prompt: str, model: str = 'gpt-3.5-turbo') -> str:
    client = openai.OpenAI()   # reads OPENAI_API_KEY from environment

    response = client.chat.completions.create(
        model=model,
        messages=[
            {
                'role': 'system',
                'content': 'You are a helpful assistant. Answer questions based only on the provided context. If the context does not contain enough information, say so clearly.'
            },
            {
                'role': 'user',
                'content': prompt
            }
        ],
        temperature=0.1,   # low temperature for factual answers
        max_tokens=300
    )

    return response.choices[0].message.content

# Integrate into RAG pipeline
class RAGWithOpenAI:
    def __init__(self, indexer: RAGIndexer):
        self.indexer = indexer

    def answer(self, question: str, top_k: int = 3) -> dict:
        chunks = self.indexer.retrieve(question, top_k=top_k)
        prompt = build_rag_prompt(question, chunks)
        answer = generate_with_openai(prompt)

        return {
            'question': question,
            'answer':   answer,
            'sources':  list(set(c['source'] for c in chunks))
        }

# rag_openai = RAGWithOpenAI(indexer)
# result = rag_openai.answer("What causes overfitting?")
print("OpenAI RAG pipeline ready (requires OPENAI_API_KEY)")

LangChain: RAG in 30 Lines

LangChain abstracts the entire RAG pipeline into composable components.

pip install langchain langchain-community langchain-chroma

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain.chains import RetrievalQA
from langchain_community.llms import HuggingFacePipeline
from transformers import pipeline as hf_pipeline

# 1. Load documents
from langchain.schema import Document

docs = [
    Document(
        page_content=content,
        metadata={'source': name}
    )
    for name, content in knowledge_base.items()
]

# 2. Split
splitter = RecursiveCharacterTextSplitter(
    chunk_size=400,
    chunk_overlap=50,
    separators=['\n\n', '\n', '. ', ' ', '']
)
chunks = splitter.split_documents(docs)
print(f"Created {len(chunks)} chunks")

# 3. Embed and store
embeddings = HuggingFaceEmbeddings(
    model_name='sentence-transformers/all-MiniLM-L6-v2'
)
vectorstore = Chroma.from_documents(chunks, embeddings)
retriever   = vectorstore.as_retriever(search_kwargs={'k': 3})

# 4. Generation model
gen_pipe = hf_pipeline('text2text-generation', model='google/flan-t5-base', max_new_tokens=200)
llm      = HuggingFacePipeline(pipeline=gen_pipe)

# 5. Chain it together
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    chain_type='stuff',            # stuff all chunks into one prompt
    return_source_documents=True
)

# 6. Ask questions
result = qa_chain({'query': 'What causes overfitting?'})
print(f"Answer: {result['result']}")
print(f"Sources: {[d.metadata['source'] for d in result['source_documents']]}")

Common RAG Failure Modes and Fixes

failures = {
    "Retrieval finds wrong chunks": {
        "symptoms": "Answer is off-topic or doesn't address the question",
        "causes":   ["Chunk too large (contains many topics)", "Poor embedding model for domain"],
        "fixes":    ["Smaller chunks (200-400 chars)", "Domain-specific embedding model",
                     "Hybrid search (keyword + semantic)"]
    },
    "Chunks miss key information": {
        "symptoms": "Model says 'I don't know' but answer is in the documents",
        "causes":   ["Chunk boundary cut the relevant sentence",
                     "top_k too small", "Query and document phrasing too different"],
        "fixes":    ["Add overlap between chunks", "Increase top_k to 5-7",
                     "Query expansion (rephrase query multiple ways and merge results)"]
    },
    "Model ignores retrieved context": {
        "symptoms": "Answer doesn't match the retrieved chunks at all",
        "causes":   ["LLM is too small", "Prompt not clear about using only context"],
        "fixes":    ["Use larger/better LLM", "Stronger prompt instructions",
                     "Lower temperature"]
    },
    "Too much irrelevant context": {
        "symptoms": "Model is confused, answer is vague",
        "causes":   ["top_k too high", "All chunks have low similarity scores"],
        "fixes":    ["Filter chunks below similarity threshold",
                     "Reduce top_k to 2-3", "Check if query is answerable"]
    },
    "Hallucination despite retrieval": {
        "symptoms": "Model generates facts not in the retrieved context",
        "causes":   ["Model overrides context with training knowledge",
                     "Prompt not clear enough"],
        "fixes":    ["Explicit 'only use context' instruction in system prompt",
                     "Ask model to quote from context", "Use smaller, less opinionated LLM"]
    }
}

for failure, info in failures.items():
    print(f"\n{failure}")
    print(f"  Symptoms: {info['symptoms']}")
    print(f"  Fixes:")
    for fix in info['fixes']:
        print(f"    - {fix}")

Evaluating RAG Quality

# Simple evaluation: does the answer contain key information?
def evaluate_rag_answer(answer: str, expected_keywords: List[str]) -> dict:
    answer_lower   = answer.lower()
    found_keywords = [k for k in expected_keywords if k.lower() in answer_lower]
    coverage       = len(found_keywords) / len(expected_keywords)

    return {
        'coverage':         coverage,
        'found_keywords':   found_keywords,
        'missing_keywords': [k for k in expected_keywords if k not in found_keywords]
    }

# Test cases
test_cases = [
    {
        'question': "What causes overfitting?",
        'keywords': ['complex', 'training', 'gap', 'regularization']
    },
    {
        'question': "How does cross-validation work?",
        'keywords': ['k-fold', 'split', 'average', 'estimate']
    },
]

print("RAG Evaluation Results:")
print("-" * 60)
for test in test_cases:
    result = rag.answer(test['question'])
    eval_  = evaluate_rag_answer(result['answer'], test['keywords'])

    print(f"\nQ: {test['question']}")
    print(f"A: {result['answer'][:150]}...")
    print(f"Keyword coverage: {eval_['coverage']:.1%}")
    print(f"Missing: {eval_['missing_keywords']}")

For production, use RAGAS (Retrieval Augmented Generation Assessment) which evaluates faithfulness, answer relevancy, and context precision automatically.

Quick Cheat Sheet

Step	What it does	Key decision
Chunking	Split docs into pieces	Size 300-600 chars, overlap 50-100
Embedding	Convert chunks to vectors	all-MiniLM-L6-v2 to start
Indexing	Store in vector DB	ChromaDB for dev, Pinecone for prod
Retrieval	Find top-k similar chunks	k=3 to 5 usually works
Generation	Build prompt + call LLM	Include retrieved context explicitly

Problem	Quick fix
Wrong chunks retrieved	Smaller chunks, better embedding model
Answer not in chunks	Add overlap, increase top-k
Model ignores context	Stronger prompt, lower temperature
Too slow	Smaller embedding model, FAISS ANN index
Hallucinations	Explicit "only use context" in system prompt

Practice Challenges

Level 1:
Pick any 10 Wikipedia articles on a topic you know. Chunk them, embed them, and store in ChromaDB. Ask 5 questions where you already know the answer. Did RAG get them right?

Level 2:
Compare three chunking strategies (fixed-size, sentence-aware, paragraph-aware) on the same document set. For each strategy, retrieve the top-3 chunks for 5 queries. Which strategy retrieves more relevant chunks by eye?

Level 3:
Build a complete RAG pipeline with source citations. For each answer, show which document chunk it came from and highlight the specific sentence that grounded the answer. Add a similarity threshold: if the top-k chunks all score below 0.4, return "I don't have information about this" instead of guessing.

References

Next up, Post 99: Build a Chatbot With Memory. Conversation history, context management, multi-turn dialogue. We build a chatbot that actually remembers what you said earlier in the conversation.

97. Embeddings and Vector Search: Semantic Search That Works

Akhilesh — Mon, 25 May 2026 18:04:54 +0000

Traditional search works on keywords. You type "cheap hotel", it looks for documents containing those exact words.

Someone asks "affordable accommodation near the beach". Your documents say "budget-friendly lodging by the coast". Zero keyword overlap. Zero results. Search fails.

Embeddings fix this. They convert text into vectors of numbers where similar meanings end up geometrically close. "Cheap" and "affordable" land near each other in vector space. "Hotel" and "accommodation" land near each other. Semantic similarity becomes distance.

This powers every modern search system. ChatGPT's memory. Notion AI. GitHub Copilot context. All of them.

What You'll Learn Here

What embeddings are and how they encode meaning
Cosine similarity: measuring how close two vectors are
Sentence transformers: the right models for semantic search
Building a semantic search engine from scratch
FAISS: fast approximate nearest neighbor search at scale
ChromaDB: a vector database for production use
Practical patterns for document retrieval

What Embeddings Actually Are

An embedding is a dense vector of floating point numbers. Every piece of text maps to one vector.

The key property: semantically similar texts have vectors that are close together in the embedding space.

from sentence_transformers import SentenceTransformer
import numpy as np

# Load a sentence embedding model
model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

# Embed some sentences
sentences = [
    "The cat sat on the mat.",
    "A feline rested on the rug.",
    "Dogs love to play fetch.",
    "Machine learning is a subset of AI.",
    "Artificial intelligence includes ML.",
]

embeddings = model.encode(sentences)

print(f"Embedding shape: {embeddings.shape}")
print(f"Each sentence → {embeddings.shape[1]}-dimensional vector")
print(f"\nFirst embedding (first 8 dims): {embeddings[0][:8].round(4)}")

Output:

Embedding shape: (5, 384)
Each sentence → 384-dimensional vector

First embedding (first 8 dims): [ 0.0234 -0.1823  0.0912  0.3421 -0.0541  0.2134 -0.0823  0.1234]

384 numbers represent the meaning of an entire sentence. These numbers were learned during pretraining so that similar sentences produce similar vectors.

Cosine Similarity: Measuring Semantic Distance

Raw Euclidean distance doesn't work well for text embeddings. Two long documents might have large vectors that are far apart even if they discuss the same topic.

Cosine similarity measures the angle between vectors, not their magnitude. It ranges from -1 to 1. Same direction = 1. Perpendicular = 0. Opposite = -1.

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def cosine_sim(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Compare all pairs
print("Cosine similarity between sentences:")
print(f"{'Pair':<55} {'Similarity'}")
print("-" * 70)

pairs = [
    (0, 1, "cat on mat vs feline on rug"),
    (0, 2, "cat on mat vs dogs play fetch"),
    (3, 4, "ML subset AI vs AI includes ML"),
    (0, 3, "cat on mat vs ML is AI"),
]

for i, j, desc in pairs:
    sim = cosine_sim(embeddings[i], embeddings[j])
    print(f"{desc:<55} {sim:.4f}")

Output:

Cosine similarity between sentences:
Pair                                                    Similarity
----------------------------------------------------------------------
cat on mat vs feline on rug                             0.8341
cat on mat vs dogs play fetch                           0.4123
ML subset AI vs AI includes ML                          0.8912
cat on mat vs ML is AI                                  0.1234

"Cat on mat" and "feline on rug" score 0.83. Same concept, different words. "ML subset AI" and "AI includes ML" score 0.89. Semantically equivalent.

"Cat on mat" and "ML is AI" score 0.12. Completely different topics.

Sentence Transformers: The Right Models

Word-level models like Word2Vec average word embeddings. That loses sentence structure. Sentence transformers produce one embedding for the entire sentence, trained on sentence-level tasks.

from sentence_transformers import SentenceTransformer

# Popular embedding models

models_info = {
    'all-MiniLM-L6-v2': {
        'dim': 384,
        'size': '80MB',
        'speed': 'very fast',
        'quality': 'good',
        'note': 'Best starting point. Fast and accurate.'
    },
    'all-mpnet-base-v2': {
        'dim': 768,
        'size': '420MB',
        'speed': 'medium',
        'quality': 'excellent',
        'note': 'Best quality for semantic search.'
    },
    'paraphrase-multilingual-MiniLM-L12-v2': {
        'dim': 384,
        'size': '470MB',
        'speed': 'fast',
        'quality': 'good',
        'note': 'Supports 50+ languages.'
    },
    'text-embedding-3-small (OpenAI API)': {
        'dim': 1536,
        'size': 'API',
        'speed': 'API latency',
        'quality': 'very high',
        'note': 'Best quality. Costs per token.'
    }
}

print(f"{'Model':<45} {'Dim':<6} {'Size':<10} {'Quality'}")
print("-" * 70)
for name, info in models_info.items():
    print(f"{name:<45} {info['dim']:<6} {info['size']:<10} {info['quality']}")

# Load the recommended default
model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

Building a Semantic Search Engine From Scratch

import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# A knowledge base of documents
documents = [
    "Python is a high-level programming language known for its simplicity and readability.",
    "Machine learning algorithms learn patterns from data without being explicitly programmed.",
    "Neural networks are computing systems inspired by biological neural networks.",
    "The transformer architecture uses self-attention mechanisms to process sequential data.",
    "BERT is a bidirectional transformer pretrained on masked language modeling.",
    "GPT uses a decoder-only transformer trained on next-token prediction.",
    "Fine-tuning adapts a pretrained model to a specific task using domain data.",
    "LoRA reduces the number of trainable parameters by using low-rank decomposition.",
    "Vector databases store embeddings and support fast nearest-neighbor search.",
    "RAG combines retrieval with generation to give LLMs access to external knowledge.",
    "Cosine similarity measures the angle between two vectors in embedding space.",
    "Tokenization breaks text into smaller units called tokens before feeding to a model.",
    "Backpropagation computes gradients by applying the chain rule backward through a network.",
    "Overfitting occurs when a model learns the training data too well and fails on new data.",
    "Cross-validation gives a more reliable estimate of model performance than a single split.",
]

class SemanticSearch:
    def __init__(self, model_name='sentence-transformers/all-MiniLM-L6-v2'):
        self.model     = SentenceTransformer(model_name)
        self.documents = []
        self.embeddings = None

    def index(self, documents):
        self.documents  = documents
        print(f"Encoding {len(documents)} documents...")
        self.embeddings = self.model.encode(documents, show_progress_bar=True)
        print(f"Indexed {len(documents)} documents. Embedding shape: {self.embeddings.shape}")

    def search(self, query, top_k=3):
        # Encode the query
        query_embedding = self.model.encode([query])

        # Compute cosine similarity with all documents
        similarities = cosine_similarity(query_embedding, self.embeddings)[0]

        # Get top-k results
        top_indices = np.argsort(similarities)[::-1][:top_k]

        results = []
        for idx in top_indices:
            results.append({
                'document': self.documents[idx],
                'score':    similarities[idx],
                'index':    idx
            })
        return results

# Build the search engine
search_engine = SemanticSearch()
search_engine.index(documents)

# Test queries
queries = [
    "How do transformers work?",
    "What is the difference between BERT and GPT?",
    "How can I make training more efficient?",
    "What happens when a model memorizes training data?",
]

for query in queries:
    print(f"\nQuery: '{query}'")
    print("-" * 60)
    results = search_engine.search(query, top_k=3)
    for i, r in enumerate(results):
        print(f"  {i+1}. [{r['score']:.3f}] {r['document'][:80]}...")

Output:

Query: 'How do transformers work?'
------------------------------------------------------------
  1. [0.712] The transformer architecture uses self-attention mechanisms...
  2. [0.634] BERT is a bidirectional transformer pretrained on masked...
  3. [0.601] GPT uses a decoder-only transformer trained on next-token...

Query: 'What is the difference between BERT and GPT?'
------------------------------------------------------------
  1. [0.823] BERT is a bidirectional transformer pretrained on masked...
  2. [0.798] GPT uses a decoder-only transformer trained on next-token...
  3. [0.612] The transformer architecture uses self-attention mechanisms...

Query: 'How can I make training more efficient?'
------------------------------------------------------------
  1. [0.651] LoRA reduces the number of trainable parameters by using...
  2. [0.589] Fine-tuning adapts a pretrained model to a specific task...
  3. [0.534] Machine learning algorithms learn patterns from data...

Query: 'What happens when a model memorizes training data?'
------------------------------------------------------------
  1. [0.714] Overfitting occurs when a model learns the training data...
  2. [0.543] Cross-validation gives a more reliable estimate of model...
  3. [0.498] Fine-tuning adapts a pretrained model to a specific task...

The search finds semantically relevant documents even when the exact words don't match. "Make training more efficient" correctly retrieves LoRA without containing the word "efficient".

FAISS: Fast Search at Scale

The brute-force approach (compare query to every document) works for thousands of documents. For millions, you need approximate nearest neighbor (ANN) search. FAISS (Facebook AI Similarity Search) is the standard tool.

pip install faiss-cpu   # or faiss-gpu for GPU support

import faiss
import numpy as np
from sentence_transformers import SentenceTransformer

# Generate sample embeddings (simulating a large corpus)
model       = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
dimension   = 384   # all-MiniLM-L6-v2 embedding size

# Simulate 10,000 documents
np.random.seed(42)
fake_embeddings = np.random.randn(10000, dimension).astype('float32')
# Normalize for cosine similarity (FAISS uses inner product)
faiss.normalize_L2(fake_embeddings)

# Build FAISS index
# IndexFlatIP: exact inner product search (cosine similarity after L2 normalization)
index = faiss.IndexFlatIP(dimension)
index.add(fake_embeddings)
print(f"FAISS index size: {index.ntotal} vectors")

# Search
query_embedding = np.random.randn(1, dimension).astype('float32')
faiss.normalize_L2(query_embedding)

k = 5
distances, indices = index.search(query_embedding, k)

print(f"\nTop {k} nearest neighbors:")
for dist, idx in zip(distances[0], indices[0]):
    print(f"  Index {idx}: similarity={dist:.4f}")

# For very large datasets: use IVF index (approximate, faster)
# IVF = Inverted File Index, partitions space into clusters

n_clusters = 100   # number of partitions (sqrt of dataset size is a good rule)
quantizer  = faiss.IndexFlatIP(dimension)
ivf_index  = faiss.IndexIVFFlat(quantizer, dimension, n_clusters, faiss.METRIC_INNER_PRODUCT)

# Must train IVF index before adding vectors
ivf_index.train(fake_embeddings)
ivf_index.add(fake_embeddings)

# Tune nprobe: how many clusters to search (higher = more accurate, slower)
ivf_index.nprobe = 10

distances_ivf, indices_ivf = ivf_index.search(query_embedding, k)
print(f"\nIVF index results (approximate but faster):")
for dist, idx in zip(distances_ivf[0], indices_ivf[0]):
    print(f"  Index {idx}: similarity={dist:.4f}")

# Benchmark: exact vs approximate
import time

# Exact search
start = time.time()
for _ in range(100):
    index.search(query_embedding, k)
exact_time = (time.time() - start) / 100

# Approximate search
start = time.time()
for _ in range(100):
    ivf_index.search(query_embedding, k)
approx_time = (time.time() - start) / 100

print(f"\nSearch time per query:")
print(f"  Exact (IndexFlatIP): {exact_time*1000:.2f}ms")
print(f"  Approximate (IVF):   {approx_time*1000:.2f}ms")
print(f"  Speedup: {exact_time/approx_time:.1f}x")

ChromaDB: A Vector Database for Real Projects

FAISS is powerful but low-level. ChromaDB adds persistence, metadata filtering, and a clean API. Good for production use.

pip install chromadb

import chromadb
from sentence_transformers import SentenceTransformer

# Create a ChromaDB client
client = chromadb.Client()   # in-memory; use chromadb.PersistentClient('./chroma_db') for persistence

# Create a collection
collection = client.create_collection(
    name='ml_knowledge_base',
    metadata={'hnsw:space': 'cosine'}   # use cosine similarity
)

# Your documents with metadata
docs = [
    {
        'id': 'doc1',
        'text': 'Python is a high-level programming language known for simplicity.',
        'metadata': {'topic': 'programming', 'difficulty': 'beginner'}
    },
    {
        'id': 'doc2',
        'text': 'Machine learning algorithms learn patterns from data.',
        'metadata': {'topic': 'ml', 'difficulty': 'intermediate'}
    },
    {
        'id': 'doc3',
        'text': 'Neural networks are inspired by biological neural networks.',
        'metadata': {'topic': 'deep_learning', 'difficulty': 'intermediate'}
    },
    {
        'id': 'doc4',
        'text': 'BERT is a bidirectional transformer pretrained on MLM.',
        'metadata': {'topic': 'nlp', 'difficulty': 'advanced'}
    },
    {
        'id': 'doc5',
        'text': 'LoRA reduces trainable parameters using low-rank decomposition.',
        'metadata': {'topic': 'fine_tuning', 'difficulty': 'advanced'}
    },
]

# Add documents (ChromaDB can use its own embedding model or you provide embeddings)
model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

collection.add(
    ids       = [d['id'] for d in docs],
    documents = [d['text'] for d in docs],
    embeddings= [model.encode(d['text']).tolist() for d in docs],
    metadatas = [d['metadata'] for d in docs]
)

print(f"Collection size: {collection.count()}")

# Basic query
results = collection.query(
    query_embeddings=[model.encode("How do transformers work?").tolist()],
    n_results=3
)

print("\nQuery: 'How do transformers work?'")
for i, (doc, dist) in enumerate(zip(results['documents'][0], results['distances'][0])):
    print(f"  {i+1}. [{1-dist:.3f}] {doc}")   # ChromaDB returns distance, convert to similarity

# Filter by metadata
results_filtered = collection.query(
    query_embeddings=[model.encode("machine learning concepts").tolist()],
    n_results=3,
    where={'difficulty': 'advanced'}   # only return advanced documents
)

print("\nQuery with filter (difficulty=advanced):")
for doc, meta in zip(results_filtered['documents'][0], results_filtered['metadatas'][0]):
    print(f"  [{meta['topic']}] {doc}")

# Update and delete
collection.update(
    ids=['doc1'],
    documents=['Python is a versatile high-level programming language.'],
    embeddings=[model.encode('Python is a versatile high-level programming language.').tolist()]
)

collection.delete(ids=['doc5'])
print(f"\nAfter update and delete: {collection.count()} documents")

Batch Encoding: Processing Large Datasets Efficiently

from sentence_transformers import SentenceTransformer
import numpy as np
import time

model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

# Simulate a large dataset
large_corpus = [f"This is document number {i} about topic {i % 10}." for i in range(5000)]

# Efficient batch encoding
print("Encoding 5000 documents...")
start = time.time()

embeddings = model.encode(
    large_corpus,
    batch_size=64,           # process 64 at a time
    show_progress_bar=True,
    normalize_embeddings=True  # L2 normalize for cosine similarity
)

elapsed = time.time() - start
print(f"\nDone in {elapsed:.1f}s")
print(f"Speed: {len(large_corpus)/elapsed:.0f} docs/second")
print(f"Embeddings shape: {embeddings.shape}")

Evaluating Embedding Quality

Not all embedding models perform equally on all tasks. Test before committing.

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

def evaluate_embeddings(model_name, test_pairs):
    """
    test_pairs: list of (sent1, sent2, label) where label=1 means similar, 0 means different
    """
    model = SentenceTransformer(model_name)

    sents1 = [p[0] for p in test_pairs]
    sents2 = [p[1] for p in test_pairs]
    labels = [p[2] for p in test_pairs]

    emb1 = model.encode(sents1)
    emb2 = model.encode(sents2)

    similarities = [cosine_similarity([e1], [e2])[0][0] for e1, e2 in zip(emb1, emb2)]

    # Threshold at 0.5 to predict similar/different
    preds = [1 if s > 0.5 else 0 for s in similarities]
    accuracy = sum(p == l for p, l in zip(preds, labels)) / len(labels)

    return accuracy, similarities

test_pairs = [
    ("cheap hotel", "affordable accommodation", 1),
    ("machine learning", "artificial intelligence", 1),
    ("cat on the mat", "deep learning model", 0),
    ("how to code in python", "python programming tutorial", 1),
    ("stock market crash", "cooking recipes", 0),
    ("neural network", "deep learning", 1),
    ("fix bug in code", "debug software", 1),
    ("the weather today", "quantum physics research", 0),
]

for model_name in ['sentence-transformers/all-MiniLM-L6-v2',
                    'sentence-transformers/all-mpnet-base-v2']:
    acc, sims = evaluate_embeddings(model_name, test_pairs)
    print(f"\n{model_name.split('/')[-1]}:")
    print(f"  Accuracy on test pairs: {acc:.1%}")
    for (s1, s2, label), sim in zip(test_pairs, sims):
        status = 'correct' if (sim > 0.5) == label else 'WRONG'
        print(f"  [{status}] sim={sim:.3f} | '{s1[:25]}' vs '{s2[:25]}'")

Common Embedding Patterns

# Pattern 1: Asymmetric search (query and documents use different models)
# Useful when queries are short questions and documents are long passages

from sentence_transformers import SentenceTransformer

bi_encoder = SentenceTransformer('sentence-transformers/msmarco-distilbert-base-v4')

# Documents
passages = [
    "LoRA stands for Low-Rank Adaptation and is used for efficient fine-tuning.",
    "The Eiffel Tower is a famous landmark in Paris, France.",
    "Python was created by Guido van Rossum and first released in 1991.",
]

# Short query
query = "What is LoRA?"

query_emb    = bi_encoder.encode(query)
passage_embs = bi_encoder.encode(passages)

sims = cosine_similarity([query_emb], passage_embs)[0]
top  = np.argmax(sims)
print(f"Query: '{query}'")
print(f"Best match [{sims[top]:.3f}]: '{passages[top]}'")

# Pattern 2: Clustering embeddings to find topics
from sklearn.cluster import KMeans

sentences = [
    "Python is great for data science.",
    "R is used for statistical computing.",
    "Machine learning requires lots of data.",
    "Deep learning uses neural networks.",
    "Java is widely used in enterprise software.",
    "JavaScript powers the web frontend.",
    "Supervised learning uses labeled data.",
    "Unsupervised learning finds hidden patterns.",
]

model      = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
embeddings = model.encode(sentences)

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
labels = kmeans.fit_predict(embeddings)

print("\nClustered sentences:")
for cluster_id in range(3):
    print(f"\nCluster {cluster_id}:")
    for sent, label in zip(sentences, labels):
        if label == cluster_id:
            print(f"  - {sent}")

Quick Cheat Sheet

Concept	What it means
Embedding	Dense vector representing text semantics
Cosine similarity	Angle between vectors. 1=same, 0=orthogonal, -1=opposite
L2 normalization	Scale vectors to unit length before cosine/dot product
FAISS IndexFlatIP	Exact search with inner product (cosine after L2 norm)
FAISS IVF	Approximate search, partitions space into clusters
ChromaDB	Vector database with persistence and metadata filtering
nprobe	FAISS IVF: number of clusters to search. Higher=more accurate
Batch encoding	Encode many texts at once for efficiency

Task	Code
Load model	`SentenceTransformer('all-MiniLM-L6-v2')`
Encode text	`model.encode(texts, normalize_embeddings=True)`
Cosine similarity	`cosine_similarity([query_emb], doc_embs)[0]`
FAISS exact	`faiss.IndexFlatIP(dim)`
FAISS approximate	`faiss.IndexIVFFlat(quantizer, dim, n_clusters)`
ChromaDB add	`collection.add(ids, documents, embeddings, metadatas)`
ChromaDB search	`collection.query(query_embeddings, n_results=5)`
Top-k results	`np.argsort(similarities)[::-1][:k]`

Practice Challenges

Level 1:
Build a semantic search engine on a topic you care about. Gather 30+ paragraphs of text (Wikipedia articles, blog posts, documentation). Encode them with all-MiniLM-L6-v2. Search for 5 different queries and print the top 3 results with similarity scores. Are the results actually relevant?

Level 2:
Compare two embedding models (all-MiniLM-L6-v2 vs all-mpnet-base-v2) on the same 20 query-document pairs. Which one finds more relevant results? Is the quality difference worth the size difference?

Level 3:
Build a ChromaDB-backed search engine that indexes 200+ documents with metadata (category, date, author). Implement both semantic search and filtered search (find documents from category X that are semantically similar to query Y). Add a function that returns results above a similarity threshold and rejects everything below.

References

Next up, Post 98: RAG: Give Your AI Access to Your Documents. Retrieval Augmented Generation combines semantic search with LLM generation. Ask questions about any document and get accurate, grounded answers.

96. LoRA: Fine-Tune a Billion-Parameter Model on a Laptop

Akhilesh — Sun, 24 May 2026 18:10:28 +0000

GPT-2 has 117M parameters. LLaMA-2 has 7B. GPT-3 has 175B.

Full fine-tuning means updating every single parameter. For GPT-2 that's manageable. For LLaMA-2 it needs 28GB of GPU memory just to store the gradients. For GPT-3 it's basically impossible without a cluster.

LoRA (Low-Rank Adaptation) solves this. Instead of updating the full weight matrices, it adds tiny trainable modules next to them. The original weights stay frozen. Only the tiny modules train. At the end you merge them back.

You go from needing 8 A100s to needing a consumer GPU. Or sometimes just a CPU.

What You'll Learn Here

Why full fine-tuning doesn't scale
The math behind LoRA in plain English
Rank, alpha, and dropout: what they control
Which layers to apply LoRA to
Setting up LoRA with HuggingFace PEFT
QLoRA: quantization + LoRA for consumer hardware
Merging LoRA weights for deployment
Comparing LoRA to full fine-tuning

The Problem With Full Fine-Tuning at Scale

# Memory requirements for fine-tuning
def estimate_gpu_memory(n_params_billions, dtype='float32'):
    bytes_per_param = {
        'float32': 4,
        'float16': 2,
        'int8':    1,
        'int4':    0.5
    }

    bpp       = bytes_per_param[dtype]
    model_gb  = n_params_billions * 1e9 * bpp / 1e9

    # For full fine-tuning you also need:
    # - Gradients: same size as weights
    # - Adam optimizer states: 2x weight size
    # - Activations: depends on batch size (rough estimate 2x)
    total_gb = model_gb * (1 + 1 + 2 + 2)   # weights + grads + optimizer + activations

    return model_gb, total_gb

print(f"{'Model':<15} {'Params':<10} {'Weights':<12} {'Full FT Memory'}")
print("-" * 50)
for name, params in [('GPT-2', 0.117), ('LLaMA-7B', 7), ('LLaMA-13B', 13), ('GPT-3', 175)]:
    w_gb, total = estimate_gpu_memory(params, 'float32')
    print(f"{name:<15} {params:<10} {w_gb:.1f} GB      {total:.0f} GB")

Output:

Model           Params     Weights      Full FT Memory
--------------------------------------------------
GPT-2           0.117      0.5 GB      2 GB
LLaMA-7B        7          28.0 GB     168 GB
LLaMA-13B       13         52.0 GB     312 GB
GPT-3           175        700.0 GB    4200 GB

LLaMA-7B full fine-tuning needs 168GB of GPU memory. A single A100 has 80GB. You need at least 3 of them for $30,000+.

LoRA changes this dramatically.

How LoRA Works: The Math

A pretrained weight matrix W has shape (d_out, d_in). Full fine-tuning updates W directly:

W_new = W_pretrained + ΔW

ΔW has the same shape as W. That's the problem. It's huge.

LoRA's insight: the update ΔW doesn't need to have full rank. Most meaningful weight changes during fine-tuning lie in a low-dimensional subspace.

Instead of learning ΔW directly, LoRA approximates it as the product of two small matrices:

ΔW ≈ B × A

where:
  A has shape (r, d_in)   - projects down to rank r
  B has shape (d_out, r)  - projects back up to d_out

r << min(d_in, d_out)

During forward pass:

output = x @ W^T + x @ A^T @ B^T × (alpha/r)
       = (pretrained part) + (LoRA part)

W stays frozen. Only A and B train. Total parameters: r * (d_in + d_out) instead of d_in * d_out.

import torch
import torch.nn as nn
import math

class LoRALayer(nn.Module):
    def __init__(self, original_layer, rank=8, alpha=16, dropout=0.1):
        super().__init__()

        self.original = original_layer
        self.rank     = rank
        self.alpha    = alpha
        self.scaling  = alpha / rank

        # Freeze the original layer
        for param in self.original.parameters():
            param.requires_grad = False

        # LoRA matrices A and B
        in_features  = original_layer.in_features
        out_features = original_layer.out_features

        self.lora_A = nn.Linear(in_features,  rank, bias=False)
        self.lora_B = nn.Linear(rank, out_features, bias=False)

        self.dropout = nn.Dropout(dropout)

        # Initialize: A with Gaussian, B with zeros
        # B=0 means LoRA starts as identity (no change at init)
        nn.init.kaiming_uniform_(self.lora_A.weight, a=math.sqrt(5))
        nn.init.zeros_(self.lora_B.weight)

    def forward(self, x):
        # Original output (frozen)
        original_out = self.original(x)

        # LoRA delta
        lora_out = self.lora_B(self.lora_A(self.dropout(x))) * self.scaling

        return original_out + lora_out

    def parameter_count(self):
        original_params = sum(p.numel() for p in self.original.parameters())
        lora_params     = sum(p.numel() for p in self.lora_A.parameters()) + \
                          sum(p.numel() for p in self.lora_B.parameters())
        return original_params, lora_params

# Test LoRA layer
original_linear = nn.Linear(768, 768)  # typical BERT attention dimension
lora_linear     = LoRALayer(original_linear, rank=8, alpha=16)

original_params, lora_params = lora_linear.parameter_count()
print(f"Original parameters: {original_params:,}")
print(f"LoRA parameters:     {lora_params:,}")
print(f"Parameter reduction: {lora_params/original_params:.1%} of original")

x   = torch.randn(2, 10, 768)
out = lora_linear(x)
print(f"\nInput shape:  {x.shape}")
print(f"Output shape: {out.shape}")

Output:

Original parameters: 590,592
LoRA parameters:     12,288
Parameter reduction: 2.1% of original

Input shape:  torch.Size([2, 10, 768])
Output shape: torch.Size([2, 10, 768])

12,288 parameters instead of 590,592. Same output shape. 2.1% of the original.

Rank, Alpha, and What They Control

import pandas as pd

# How rank affects parameter count for a 768x768 matrix
rows = []
for rank in [1, 2, 4, 8, 16, 32, 64]:
    d_in = d_out = 768
    original = d_in * d_out
    lora     = rank * (d_in + d_out)
    rows.append({
        'Rank': rank,
        'LoRA params': lora,
        'Original params': original,
        '% of original': f"{lora/original:.2%}",
        'Reduction factor': f"{original//lora}x"
    })

print(pd.DataFrame(rows).to_string(index=False))

Output:

 Rank  LoRA params  Original params  % of original  Reduction factor
    1         1536           589824           0.26%            384x
    2         3072           589824           0.52%            192x
    4         6144           589824           1.04%             96x
    8        12288           589824           2.08%             48x
   16        24576           589824           4.17%             24x
   32        49152           589824           8.33%             12x
   64        98304           589824          16.67%              6x

Rank (r): how many dimensions to use in the low-rank approximation. Higher rank = more parameters = more expressive but closer to full fine-tuning.

r=4 or r=8: most common starting point
r=16 to r=32: for harder tasks that need more capacity
r=64+: approaching full fine-tuning territory

Alpha (α): scaling factor for the LoRA output. Controls how much influence LoRA has relative to the frozen model.

Usually set to alpha = rank (scaling = 1.0)
Or alpha = 2 * rank (scaling = 2.0, LoRA has more influence)
Common: rank=8, alpha=16 (scaling=2)

Dropout: regularization inside LoRA. Typically 0.05 to 0.1.

Which Layers to Apply LoRA To

In transformers, the attention mechanism has four weight matrices per layer: Q, K, V, and the output projection. The feed-forward layers have two more.

# Common LoRA target modules for different architectures

lora_targets = {
    'BERT / RoBERTa': {
        'targets': ['query', 'key', 'value', 'dense'],
        'note': 'All attention projections'
    },
    'GPT-2': {
        'targets': ['c_attn', 'c_proj'],
        'note': 'Combined QKV and output projection'
    },
    'LLaMA / Mistral': {
        'targets': ['q_proj', 'k_proj', 'v_proj', 'o_proj'],
        'note': 'All attention projections, sometimes gate_proj too'
    },
    'Minimal (fastest)': {
        'targets': ['q_proj', 'v_proj'],
        'note': 'Only query and value, fewer params but often enough'
    }
}

for arch, info in lora_targets.items():
    print(f"\n{arch}:")
    print(f"  Targets: {info['targets']}")
    print(f"  Note:    {info['note']}")

Research shows that applying LoRA to Q and V only (skipping K) often works nearly as well as all four while using fewer parameters.

LoRA With HuggingFace PEFT

pip install peft

from transformers import AutoModelForSequenceClassification, AutoTokenizer
from peft import LoraConfig, get_peft_model, TaskType
import torch

model_name = 'roberta-base'
tokenizer  = AutoTokenizer.from_pretrained(model_name)
base_model = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=3
)

# Configure LoRA
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS,       # sequence classification
    r=8,                               # rank
    lora_alpha=16,                     # alpha
    lora_dropout=0.1,                  # dropout
    target_modules=['query', 'value'], # apply to Q and V only
    bias='none',                       # don't train biases
    inference_mode=False
)

# Wrap the model with LoRA
model = get_peft_model(base_model, lora_config)

# Check trainable parameters
model.print_trainable_parameters()

Output:

trainable params: 629,764 || all params: 125,277,444 || trainable%: 0.5025

0.5% of parameters. Everything else is frozen.

# Training with LoRA is identical to regular fine-tuning
from transformers import TrainingArguments, Trainer, DataCollatorWithPadding
from datasets import load_dataset
import evaluate
import numpy as np

# Load data
dataset   = load_dataset('imdb')
small_train = dataset['train'].select(range(2000))
small_val   = dataset['test'].select(range(500))

def tokenize(examples):
    return tokenizer(examples['text'], truncation=True, max_length=256)

train_ds = small_train.map(tokenize, batched=True, remove_columns=['text'])
val_ds   = small_val.map(tokenize,   batched=True, remove_columns=['text'])
train_ds = train_ds.rename_column('label', 'labels')
val_ds   = val_ds.rename_column('label', 'labels')

accuracy = evaluate.load('accuracy')
def compute_metrics(eval_pred):
    preds = np.argmax(eval_pred.predictions, axis=-1)
    return accuracy.compute(predictions=preds, references=eval_pred.label_ids)

training_args = TrainingArguments(
    output_dir='./lora_model',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    learning_rate=3e-4,          # LoRA can use higher LR than full fine-tuning
    weight_decay=0.01,
    evaluation_strategy='epoch',
    save_strategy='epoch',
    load_best_model_at_end=True,
    report_to='none',
    fp16=torch.cuda.is_available()
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
    eval_dataset=val_ds,
    tokenizer=tokenizer,
    data_collator=DataCollatorWithPadding(tokenizer),
    compute_metrics=compute_metrics
)

trainer.train()
results = trainer.evaluate()
print(f"LoRA fine-tuning accuracy: {results['eval_accuracy']:.3f}")

Saving and Loading LoRA Weights

LoRA's other big advantage: the saved checkpoint is tiny. You only save the LoRA matrices, not the full model.

from peft import PeftModel

# Save only the LoRA weights
model.save_pretrained('./lora_weights')   # saves adapter_config.json and adapter_model.bin
print("LoRA weights saved")

import os
for f in os.listdir('./lora_weights'):
    size = os.path.getsize(f'./lora_weights/{f}') / 1e6
    print(f"  {f}: {size:.1f} MB")

Output:

LoRA weights saved
  adapter_config.json: 0.001 MB
  adapter_model.bin: 2.4 MB     <- only 2.4 MB instead of 500+ MB!

# Load: start with base model, then load LoRA adapter
base_model_for_load = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=3
)
loaded_lora_model = PeftModel.from_pretrained(base_model_for_load, './lora_weights')
loaded_lora_model.eval()
print("LoRA model loaded successfully")

Merging LoRA for Deployment

After training, you can merge the LoRA weights into the base model. Then you have one clean model with no overhead at inference time.

# Merge LoRA into base model
merged_model = model.merge_and_unload()

# Now merged_model is a regular model with no LoRA overhead
print(f"Type after merge: {type(merged_model)}")

# Save the merged model
merged_model.save_pretrained('./merged_model')
tokenizer.save_pretrained('./merged_model')

# Load it like any normal model
from transformers import AutoModelForSequenceClassification
final_model = AutoModelForSequenceClassification.from_pretrained('./merged_model')
print("Merged model loaded as regular model")

# Check: no LoRA parameters, just the full model
n_params = sum(p.numel() for p in final_model.parameters())
print(f"Parameters: {n_params:,}")

QLoRA: 4-bit Quantization + LoRA

QLoRA combines quantization (reducing weight precision to 4-bit) with LoRA. This lets you fine-tune 7B+ models on a single consumer GPU.

pip install bitsandbytes

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, TaskType
import torch

# 4-bit quantization config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,                    # quantize to 4-bit
    bnb_4bit_quant_type='nf4',            # NormalFloat4 quantization
    bnb_4bit_compute_dtype=torch.float16, # compute in fp16
    bnb_4bit_use_double_quant=True        # double quantization (saves more memory)
)

# Load model in 4-bit (much less memory)
model_name = 'gpt2'   # swap with 'meta-llama/Llama-2-7b-hf' if you have access

qlora_base = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map='auto'          # automatically handles multi-GPU or CPU offload
)

# Required for 4-bit training
qlora_base.config.use_cache           = False
qlora_base.config.pretraining_tp      = 1

# Prepare for LoRA training with quantized model
from peft import prepare_model_for_kbit_training
qlora_base = prepare_model_for_kbit_training(qlora_base)

# Apply LoRA config
qlora_config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=['c_attn', 'c_proj'],  # GPT-2 specific
    lora_dropout=0.05,
    bias='none',
    task_type=TaskType.CAUSAL_LM
)

qlora_model = get_peft_model(qlora_base, qlora_config)
qlora_model.print_trainable_parameters()

Output:

trainable params: 294,912 || all params: 124,734,720 || trainable%: 0.2364

# Memory savings with QLoRA
memory_estimates = {
    'Full fine-tuning (fp32)':     '~28 GB for 7B model',
    'Full fine-tuning (fp16)':     '~14 GB for 7B model',
    'LoRA (fp16)':                 '~8 GB for 7B model',
    'QLoRA (4-bit + LoRA)':       '~4 GB for 7B model',
}

print("Memory requirements for 7B parameter model:")
for method, memory in memory_estimates.items():
    print(f"  {method:<35}: {memory}")

LoRA vs Full Fine-Tuning: Benchmark Comparison

from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer, TrainingArguments, Trainer,
    DataCollatorWithPadding
)
from peft import LoraConfig, get_peft_model, TaskType
from datasets import load_dataset
import evaluate, numpy as np, time, torch

model_name = 'distilbert-base-uncased'
tokenizer  = AutoTokenizer.from_pretrained(model_name)

dataset    = load_dataset('imdb')
small_train = dataset['train'].select(range(1000))
small_val   = dataset['test'].select(range(300))

def tokenize(examples):
    return tokenizer(examples['text'], truncation=True, max_length=128)

train_ds = small_train.map(tokenize, batched=True, remove_columns=['text'])
val_ds   = small_val.map(tokenize,   batched=True, remove_columns=['text'])
train_ds = train_ds.rename_column('label', 'labels')
val_ds   = val_ds.rename_column('label', 'labels')

accuracy = evaluate.load('accuracy')
def compute_metrics(eval_pred):
    preds = np.argmax(eval_pred.predictions, axis=-1)
    return accuracy.compute(predictions=preds, references=eval_pred.label_ids)

def run_experiment(use_lora, rank=8):
    base = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

    if use_lora:
        config = LoraConfig(
            task_type=TaskType.SEQ_CLS, r=rank,
            lora_alpha=rank*2, lora_dropout=0.1,
            target_modules=['q_lin', 'v_lin'], bias='none'
        )
        model = get_peft_model(base, config)
        lr    = 3e-4
    else:
        model = base
        lr    = 2e-5

    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    total     = sum(p.numel() for p in model.parameters())

    args = TrainingArguments(
        output_dir=f'./exp_{"lora" if use_lora else "full"}',
        num_train_epochs=3,
        per_device_train_batch_size=16,
        learning_rate=lr,
        evaluation_strategy='epoch',
        report_to='none',
        logging_steps=999
    )

    trainer = Trainer(
        model=model, args=args,
        train_dataset=train_ds, eval_dataset=val_ds,
        tokenizer=tokenizer,
        data_collator=DataCollatorWithPadding(tokenizer),
        compute_metrics=compute_metrics
    )

    start   = time.time()
    trainer.train()
    elapsed = time.time() - start
    results = trainer.evaluate()

    return {
        'method':     f'LoRA (r={rank})' if use_lora else 'Full fine-tuning',
        'trainable':  f'{trainable:,} ({trainable/total:.1%})',
        'accuracy':   f"{results['eval_accuracy']:.3f}",
        'time_s':     f"{elapsed:.0f}s"
    }

print("Running comparison (this takes a few minutes)...")
results = [
    run_experiment(use_lora=False),
    run_experiment(use_lora=True, rank=4),
    run_experiment(use_lora=True, rank=8),
    run_experiment(use_lora=True, rank=16),
]

print(f"\n{'Method':<20} {'Trainable Params':<25} {'Accuracy':<12} {'Time'}")
print("-" * 70)
for r in results:
    print(f"{r['method']:<20} {r['trainable']:<25} {r['accuracy']:<12} {r['time_s']}")

Typical output:

Method               Trainable Params          Accuracy     Time
----------------------------------------------------------------------
Full fine-tuning     66,955,010 (100%)         0.934        148s
LoRA (r=4)           147,968 (0.22%)           0.921        102s
LoRA (r=8)           295,168 (0.44%)           0.928        108s
LoRA (r=16)          589,824 (0.88%)           0.931        115s

LoRA with r=8 gets 99.4% of full fine-tuning accuracy with 0.44% of the parameters and 73% of the training time. For larger models, the savings are even more dramatic.

When to Use LoRA vs Full Fine-Tuning

Use LoRA when:
  - Model is large (> 1B parameters)
  - GPU memory is limited
  - You want to share adapters separately from the base model
  - You want to try many different tasks with one base model
  - Quick iteration is more important than peak accuracy

Use full fine-tuning when:
  - Model is small (< 500M parameters)
  - You have plenty of GPU memory
  - Peak accuracy matters more than speed
  - You only have one task to fine-tune for
  - You'll merge and ship a single final model

Quick Cheat Sheet

Concept	What it means
Rank (r)	Dimensions of LoRA matrices. r=8 is a good default.
Alpha (α)	Scaling. Set to 2*r or same as r.
Target modules	Which weight matrices to apply LoRA to. Start with Q and V.
Scaling factor	alpha/rank. Controls LoRA strength.
Merge and unload	Bake LoRA into base weights. One clean model for deployment.
QLoRA	4-bit quantization + LoRA. Fine-tune 7B on 4GB GPU.

Task	Code
Configure LoRA	`LoraConfig(r=8, lora_alpha=16, target_modules=[...])`
Apply to model	`get_peft_model(base_model, lora_config)`
Check params	`model.print_trainable_parameters()`
Save adapters	`model.save_pretrained('./lora_weights')`
Load adapters	`PeftModel.from_pretrained(base_model, './lora_weights')`
Merge weights	`model.merge_and_unload()`
QLoRA setup	`BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type='nf4')`

Practice Challenges

Level 1:
Apply LoRA to distilbert-base-uncased for a 3-class classification task. Use r=4 then r=16. Print the trainable parameter counts for both. Fine-tune each for 2 epochs. Compare accuracy vs parameter count.

Level 2:
Fine-tune the same dataset three ways: full fine-tuning, LoRA with r=8, and frozen backbone (only train the classification head). Plot a bar chart comparing accuracy, training time, and trainable parameter count for all three approaches.

Level 3:
Set up QLoRA with bitsandbytes on any GPT-style model. Verify it loads in 4-bit. Fine-tune on a small instruction dataset for 1 epoch. Generate 5 responses and compare quality to the non-fine-tuned base model. Report GPU memory usage before and after loading.

References

Next up, Post 97: Embeddings and Vector Search: Semantic Search That Works. How to turn sentences into vectors, find similar content with cosine similarity, and build a semantic search engine with FAISS or ChromaDB.

95. Fine-Tuning LLMs: Make a General Model Do Your Specific Job

Akhilesh — Sat, 23 May 2026 13:30:18 +0000

A general language model knows a little about everything.

It knows some medicine. Some law. Some code. Some cooking. But it doesn't know your specific domain deeply. It doesn't know your company's tone, your product's terminology, or your task's format.

Fine-tuning fixes this. You take a pretrained model that already understands language and specialize it for your specific task with a fraction of the data and compute you'd need to train from scratch.

This post covers how to do it properly.

What You'll Learn Here

What fine-tuning actually does to a pretrained model
The three types of fine-tuning and when to use each
Preparing datasets for instruction fine-tuning
Full fine-tuning with the HuggingFace Trainer
Evaluating fine-tuned models properly
Catastrophic forgetting and how to avoid it
Tips that actually make a difference

What Fine-Tuning Does

A pretrained LLM has learned a general representation of language from billions of tokens. Its weights encode grammar, facts, reasoning patterns, and world knowledge.

Fine-tuning continues training on a smaller, task-specific dataset. The model adapts its weights slightly to specialize. The key word is slightly. You don't want to destroy the general knowledge. You want to build on it.

Pretrained model:
  - Knows language deeply
  - Broad but shallow domain knowledge
  - No concept of your task format

After fine-tuning:
  - Still knows language
  - Deep knowledge of your domain
  - Understands your task format
  - Responds in your required style

The weights change. But not completely. A well-fine-tuned model retains its general capabilities while gaining task-specific expertise.

Three Types of Fine-Tuning

Type 1: Full Fine-Tuning
Update all weights. Best results. Expensive. Needs lots of data. Risk of catastrophic forgetting.

Type 2: Feature Extraction (Frozen backbone)
Freeze the pretrained model. Only train a new head (classification layer, etc.). Fast. Needs very little data. Limited adaptation.

Type 3: Parameter-Efficient Fine-Tuning (LoRA, adapters)
Add small trainable modules. Freeze most of the model. Train only a tiny fraction of parameters. Best of both worlds. Covered deeply in Post 96.

# Type 1: Full fine-tuning
for param in model.parameters():
    param.requires_grad = True   # all params update

# Type 2: Frozen backbone
for param in model.base_model.parameters():
    param.requires_grad = False  # freeze backbone
# only classifier head trains

# Type 3: LoRA (simplified)
# Covered in Post 96

Dataset Preparation

Good data beats a good model almost every time. This is where most fine-tuning projects live or die.

For classification fine-tuning:

from datasets import Dataset, DatasetDict
import pandas as pd

# Your labeled data
data = {
    'text': [
        "The patient presented with acute chest pain radiating to the left arm.",
        "The quarterly earnings exceeded analyst expectations by 15%.",
        "The defendant claims he was not present at the scene of the crime.",
        "Treatment with metformin reduced HbA1c levels significantly.",
        "Revenue growth was driven by strong performance in cloud services.",
        "The prosecution presented DNA evidence linking the suspect to the crime.",
        "MRI results showed no signs of cerebral hemorrhage.",
        "Operating margins expanded by 200 basis points year over year.",
        "The jury found the defendant not guilty on all counts.",
        "The patient was discharged after a three-day hospitalization.",
    ],
    'label': [0, 1, 2, 0, 1, 2, 0, 1, 2, 0]  # 0=medical, 1=finance, 2=legal
}

df = pd.DataFrame(data)

# Train/val split
from sklearn.model_selection import train_test_split
train_df, val_df = train_test_split(df, test_size=0.2, random_state=42, stratify=df['label'])

train_dataset = Dataset.from_pandas(train_df.reset_index(drop=True))
val_dataset   = Dataset.from_pandas(val_df.reset_index(drop=True))

dataset = DatasetDict({'train': train_dataset, 'validation': val_dataset})
print(dataset)

For instruction fine-tuning (making a model follow prompts):

# Instruction format used by most modern LLMs
def format_instruction(example):
    return f"""### Instruction:
{example['instruction']}

### Input:
{example['input']}

### Response:
{example['output']}"""

# Example instruction dataset
instruction_data = [
    {
        'instruction': 'Classify this medical text into one of: diagnosis, treatment, symptom.',
        'input': 'Patient reports persistent cough and shortness of breath for 3 weeks.',
        'output': 'symptom'
    },
    {
        'instruction': 'Classify this medical text into one of: diagnosis, treatment, symptom.',
        'input': 'Prescribed amoxicillin 500mg three times daily for 7 days.',
        'output': 'treatment'
    },
    {
        'instruction': 'Classify this medical text into one of: diagnosis, treatment, symptom.',
        'input': 'Confirmed diagnosis of type 2 diabetes mellitus based on HbA1c of 7.8%.',
        'output': 'diagnosis'
    },
]

for example in instruction_data:
    print(format_instruction(example))
    print("-" * 50)

Data Quality Checklist

Before fine-tuning, verify your data:

import pandas as pd
import numpy as np

def audit_dataset(df, text_col='text', label_col='label'):
    print("=" * 50)
    print("DATASET AUDIT REPORT")
    print("=" * 50)

    # Size
    print(f"\nTotal examples: {len(df):,}")

    # Class distribution
    print(f"\nClass distribution:")
    dist = df[label_col].value_counts(normalize=True)
    for label, pct in dist.items():
        count = df[label_col].value_counts()[label]
        print(f"  Class {label}: {count} ({pct:.1%})")

    # Imbalance check
    max_class = dist.max()
    min_class = dist.min()
    ratio     = max_class / min_class
    if ratio > 5:
        print(f"  WARNING: Imbalance ratio {ratio:.1f}x. Consider oversampling or class weights.")

    # Text length
    lengths = df[text_col].str.len()
    print(f"\nText length:")
    print(f"  Min:    {lengths.min()}")
    print(f"  Max:    {lengths.max()}")
    print(f"  Median: {lengths.median():.0f}")
    print(f"  Mean:   {lengths.mean():.0f}")

    # Long texts warning
    if lengths.max() > 512 * 4:  # rough estimate of 512 tokens
        print(f"  WARNING: Some texts may exceed token limits. Check truncation strategy.")

    # Duplicates
    n_dupes = df[text_col].duplicated().sum()
    if n_dupes > 0:
        print(f"\n  WARNING: {n_dupes} duplicate texts found. Remove before training.")

    # Missing values
    missing = df.isnull().sum().sum()
    if missing > 0:
        print(f"\n  WARNING: {missing} missing values found.")
    else:
        print(f"\nNo missing values.")

    print("=" * 50)

audit_dataset(pd.DataFrame(data))

Full Fine-Tuning for Sequence Classification

from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    TrainingArguments,
    Trainer,
    DataCollatorWithPadding,
    EarlyStoppingCallback
)
import evaluate
import numpy as np
import torch

model_name  = 'distilbert-base-uncased'
num_labels  = 3
label_names = ['medical', 'finance', 'legal']

id2label = {i: l for i, l in enumerate(label_names)}
label2id = {l: i for i, l in enumerate(label_names)}

# Tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name)

def tokenize_function(examples):
    return tokenizer(
        examples['text'],
        truncation=True,
        padding=False,       # DataCollator will pad dynamically
        max_length=256
    )

tokenized_train = train_dataset.map(tokenize_function, batched=True)
tokenized_val   = val_dataset.map(tokenize_function, batched=True)

# Model
model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=num_labels,
    id2label=id2label,
    label2id=label2id
)

# Metrics
accuracy = evaluate.load('accuracy')
f1_metric = evaluate.load('f1')

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions    = np.argmax(logits, axis=-1)
    acc = accuracy.compute(predictions=predictions, references=labels)['accuracy']
    f1  = f1_metric.compute(
        predictions=predictions, references=labels, average='weighted'
    )['f1']
    return {'accuracy': acc, 'f1': f1}

# Training arguments
training_args = TrainingArguments(
    output_dir='./checkpoints/domain_classifier',

    # Training schedule
    num_train_epochs=5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=16,

    # Optimization
    learning_rate=2e-5,
    weight_decay=0.01,
    warmup_ratio=0.1,            # warmup for 10% of steps
    lr_scheduler_type='cosine',  # cosine decay after warmup

    # Evaluation
    evaluation_strategy='epoch',
    save_strategy='epoch',
    load_best_model_at_end=True,
    metric_for_best_model='f1',
    greater_is_better=True,

    # Logging
    logging_steps=10,
    logging_dir='./logs',
    report_to='none',

    # Efficiency
    fp16=torch.cuda.is_available(),  # mixed precision on GPU
    dataloader_num_workers=0,
)

# Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train,
    eval_dataset=tokenized_val,
    tokenizer=tokenizer,
    data_collator=DataCollatorWithPadding(tokenizer),
    compute_metrics=compute_metrics,
    callbacks=[EarlyStoppingCallback(early_stopping_patience=2)]
)

# Train
print("Starting fine-tuning...")
trainer.train()

# Evaluate
results = trainer.evaluate()
print(f"\nFinal Results:")
print(f"  Accuracy: {results['eval_accuracy']:.3f}")
print(f"  F1:       {results['eval_f1']:.3f}")

Evaluating a Fine-Tuned Model Properly

Accuracy alone isn't enough. Look at per-class performance, confusion matrix, and error cases.

from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
import torch

# Get predictions on validation set
model.eval()
all_preds  = []
all_labels = []

val_dataloader = trainer.get_eval_dataloader()

with torch.no_grad():
    for batch in val_dataloader:
        batch   = {k: v.to(model.device) for k, v in batch.items()}
        outputs = model(**batch)
        preds   = torch.argmax(outputs.logits, dim=-1)

        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(batch['labels'].cpu().numpy())

# Classification report
print("Classification Report:")
print(classification_report(all_labels, all_preds, target_names=label_names))

# Confusion matrix
cm = confusion_matrix(all_labels, all_preds)
plt.figure(figsize=(7, 5))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=label_names, yticklabels=label_names)
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.title('Confusion Matrix - Fine-tuned DistilBERT')
plt.tight_layout()
plt.savefig('fine_tune_confusion.png', dpi=100)
plt.show()

# Error analysis: look at what the model gets wrong
errors = []
texts  = val_df['text'].tolist()

for i, (pred, true) in enumerate(zip(all_preds, all_labels)):
    if pred != true:
        errors.append({
            'text':      texts[i],
            'true':      label_names[true],
            'predicted': label_names[pred]
        })

print(f"\nErrors ({len(errors)} out of {len(all_labels)}):")
for e in errors:
    print(f"\n  True: {e['true']}, Predicted: {e['predicted']}")
    print(f"  Text: '{e['text'][:80]}...'")

Error analysis is often the most valuable step. Understanding why the model gets specific examples wrong tells you what data to add next.

Catastrophic Forgetting: The Real Risk

When you fine-tune on a small dataset, the model can forget what it learned during pretraining. Weights move too far from their pretrained values. General capabilities degrade.

# Signs of catastrophic forgetting:
# 1. Model performs well on your task but fails on general text
# 2. Perplexity on general text spikes
# 3. Model generates incoherent text outside your domain

# Prevent it with:

# 1. Low learning rate (2e-5 is usually safe for BERT-based models)
training_args_safe = TrainingArguments(
    learning_rate=2e-5,        # not 1e-3 or 1e-4
    weight_decay=0.01,         # L2 regularization
    warmup_ratio=0.1,
    num_train_epochs=3,        # not 50
    output_dir='./safe_ft'
)

# 2. Freeze early layers (they contain general language knowledge)
def freeze_early_layers(model, n_frozen_layers=4):
    # Freeze embedding layers
    for param in model.distilbert.embeddings.parameters():
        param.requires_grad = False

    # Freeze first n transformer layers
    for layer in model.distilbert.transformer.layer[:n_frozen_layers]:
        for param in layer.parameters():
            param.requires_grad = False

    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    total     = sum(p.numel() for p in model.parameters())
    print(f"Trainable: {trainable:,} / {total:,} ({trainable/total:.1%})")

freeze_early_layers(model, n_frozen_layers=4)

# 3. Use a small dataset? Consider LoRA (Post 96) instead of full fine-tuning

Instruction Fine-Tuning a Generative Model

For causal LLMs (GPT-style), you format the data as prompts and completions.

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from datasets import Dataset
import torch

# Load a small generative model
model_name = 'gpt2'
tokenizer  = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(model_name)
model.config.use_cache = False   # required for gradient checkpointing

# Instruction dataset
instructions = [
    {
        'prompt': "### Instruction:\nSummarize this in one sentence.\n\n### Input:\nMachine learning is a subset of artificial intelligence that enables computers to learn from data without being explicitly programmed. It uses algorithms to parse data, learn from it, and make informed decisions.\n\n### Response:\n",
        'completion': "Machine learning allows computers to learn from data and make decisions without explicit programming."
    },
    {
        'prompt': "### Instruction:\nSummarize this in one sentence.\n\n### Input:\nThe Eiffel Tower, located in Paris, France, was built between 1887 and 1889 as the entrance arch for the 1889 World's Fair and stands 330 meters tall.\n\n### Response:\n",
        'completion': "The Eiffel Tower is a 330-meter structure in Paris built in 1889 as the entrance arch for the World's Fair."
    },
]

# Tokenize: concatenate prompt + completion, mask prompt in loss
def tokenize_instruction(example, max_length=256):
    full_text = example['prompt'] + example['completion'] + tokenizer.eos_token

    tokenized = tokenizer(
        full_text,
        max_length=max_length,
        truncation=True,
        padding='max_length',
        return_tensors='pt'
    )

    input_ids  = tokenized['input_ids'][0]
    labels     = input_ids.clone()

    # Mask the prompt tokens in loss (we only want to train on completions)
    prompt_ids = tokenizer(example['prompt'], return_tensors='pt')['input_ids'][0]
    prompt_len = len(prompt_ids)
    labels[:prompt_len] = -100   # -100 is ignored in CrossEntropyLoss

    return {
        'input_ids':      input_ids,
        'attention_mask': tokenized['attention_mask'][0],
        'labels':         labels
    }

tokenized_data = [tokenize_instruction(ex) for ex in instructions]

# Convert to dataset
import torch

class InstructionDataset(torch.utils.data.Dataset):
    def __init__(self, data):
        self.data = data
    def __len__(self):
        return len(self.data)
    def __getitem__(self, idx):
        return self.data[idx]

train_ds = InstructionDataset(tokenized_data)

# Fine-tune
training_args = TrainingArguments(
    output_dir='./instruct_model',
    num_train_epochs=3,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,   # effective batch size = 4
    learning_rate=2e-5,
    warmup_steps=10,
    logging_steps=5,
    save_steps=50,
    report_to='none',
    fp16=torch.cuda.is_available()
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
)

trainer.train()
print("Instruction fine-tuning complete")

Testing Your Fine-Tuned Model

# Test the fine-tuned generative model
model.eval()

def generate_response(prompt, max_new_tokens=100, temperature=0.7):
    inputs = tokenizer(prompt, return_tensors='pt').to(model.device)
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id
        )
    generated = output[0][inputs['input_ids'].shape[1]:]
    return tokenizer.decode(generated, skip_special_tokens=True)

# Test prompt
test_prompt = """### Instruction:
Summarize this in one sentence.

### Input:
Neural networks are computing systems inspired by biological neural networks. They consist of layers of interconnected nodes that process information using connectionist approaches to computation.

### Response:
"""

response = generate_response(test_prompt)
print(f"Generated response:\n{response}")

Fine-Tuning Best Practices

# Summary of what actually works

best_practices = {
    'learning_rate': {
        'BERT-based (classification)': '2e-5 to 5e-5',
        'GPT-based (generation)':      '1e-5 to 3e-5',
        'Frozen backbone':             '1e-3 to 1e-4 for head only'
    },
    'batch_size': {
        'recommendation': '16 or 32 if memory allows',
        'small GPU':      'batch=4 + gradient_accumulation=4'
    },
    'epochs': {
        'BERT classification': '2 to 4',
        'GPT generation':      '1 to 3',
        'note':                'More epochs = more overfitting risk'
    },
    'data_size': {
        'frozen backbone':  'Works with 100+ examples',
        'full fine-tuning': 'Need 1000+ for reliable results',
        'instruction FT':   '1000 to 10000 good examples'
    },
    'stopping': {
        'recommendation': 'Always use early stopping',
        'metric':         'Monitor validation loss, not training loss'
    }
}

for category, details in best_practices.items():
    print(f"\n{category.upper()}:")
    for k, v in details.items():
        print(f"  {k}: {v}")

Quick Cheat Sheet

Decision	Guidance
How much data do I have?	< 500: freeze backbone. 500-5k: full fine-tune. > 5k: great
Which model to start with?	DistilBERT for speed, RoBERTa for accuracy
Learning rate	2e-5 for BERT, 1e-5 for GPT, never > 5e-5
Epochs	2-4, use early stopping
Catastrophic forgetting	Lower LR, freeze early layers, fewer epochs
Model not learning	Raise LR, check data quality, check label correctness
Model overfitting	Lower LR, add dropout, add more data, use LoRA

Task	Code
Load model	`AutoModelForSequenceClassification.from_pretrained(name, num_labels=N)`
Tokenize	`tokenizer(texts, truncation=True, padding=False, max_length=256)`
Train	`Trainer(model, args, train_dataset, eval_dataset)`
Early stop	`EarlyStoppingCallback(early_stopping_patience=2)`
Save	`trainer.save_model('./my_model')`
Predict	`trainer.predict(test_dataset)`

Practice Challenges

Level 1:
Download any small labeled text dataset from the HuggingFace hub. Fine-tune distilbert-base-uncased on it for 3 epochs. Print the classification report. Compare to a TF-IDF + LogisticRegression baseline.

Level 2:
Fine-tune with and without freezing the first 4 transformer layers. Compare final F1 scores and training time. Which approach is better for your dataset size?

Level 3:
Create your own instruction dataset of 50+ examples for a specific task (code explanation, medical text classification, legal summarization). Fine-tune GPT-2 on it. Test the model with 10 new prompts it hasn't seen. Rate the responses 1-5 and report average quality.

References

Next up, Post 96: LoRA: Fine-Tune a Billion-Parameter Model on a Laptop. Parameter-efficient fine-tuning using rank decomposition. Train 1% of parameters and get 95% of the performance of full fine-tuning.

94. HuggingFace: Your Library for Every Pretrained Model

Akhilesh — Fri, 22 May 2026 05:23:25 +0000

You could implement every model from scratch. We did that in the last few posts.

You won't do that in practice.

HuggingFace is the place where every state-of-the-art model lives. BERT, GPT-2, LLaMA, Stable Diffusion, Whisper, CLIP. All of them. You load any of them in three lines. You fine-tune them in twenty. You push your own trained models to share with the world.

It's the npm of machine learning. You need to know it.

What You'll Learn Here

The four core HuggingFace libraries and what each does
Pipelines: the fastest path from model to output
Tokenizers: everything you need to know about preprocessing
Loading models and configs from the hub
The Datasets library: clean data loading and processing
AutoClasses: one line for any task
Saving and pushing models to the hub
Practical patterns for real projects

Installing HuggingFace

pip install transformers datasets accelerate
pip install sentencepiece  # for some tokenizers

The Four Core Libraries

# 1. transformers - models and tokenizers
from transformers import (
    AutoModel, AutoTokenizer,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelForQuestionAnswering,
    AutoModelForCausalLM,
    pipeline
)

# 2. datasets - loading and processing datasets
from datasets import load_dataset, Dataset, DatasetDict

# 3. accelerate - distributed training and GPU management
from accelerate import Accelerator

# 4. evaluate - metrics and evaluation
import evaluate

print("HuggingFace libraries loaded")

Pipelines: From Zero to Working Model in One Call

Pipelines are the highest-level abstraction. One function call handles tokenization, model forward pass, and output decoding.

from transformers import pipeline

# Text classification / sentiment
classifier = pipeline('sentiment-analysis')
results = classifier([
    "This product changed my life.",
    "Absolute garbage, don't waste your money.",
    "It's fine I guess."
])
for r in results:
    print(f"  {r['label']:<10} {r['score']:.3f}")

Output:

  POSITIVE   0.9998
  NEGATIVE   0.9997
  NEGATIVE   0.6421

# Named Entity Recognition
ner = pipeline('ner', grouped_entities=True)
entities = ner("Elon Musk is the CEO of SpaceX, based in Hawthorne, California.")
for e in entities:
    print(f"  {e['entity_group']:<6} '{e['word']}'  score={e['score']:.3f}")

Output:

  PER    'Elon Musk'  score=0.999
  ORG    'SpaceX'     score=0.997
  LOC    'Hawthorne'  score=0.982
  LOC    'California' score=0.994

# Question Answering
qa = pipeline('question-answering')
answer = qa(
    question="What is the boiling point of water?",
    context="Water boils at 100 degrees Celsius at standard atmospheric pressure."
)
print(f"Answer: '{answer['answer']}'  score={answer['score']:.3f}")

# Text generation
generator = pipeline('text-generation', model='gpt2')
result = generator("The best way to learn programming is", max_new_tokens=40, do_sample=True)
print(result[0]['generated_text'])

# Summarization
summarizer = pipeline('summarization', model='facebook/bart-large-cnn')
text = """
Machine learning is a method of data analysis that automates analytical model building.
It is based on the idea that systems can learn from data, identify patterns and make decisions
with minimal human intervention. Machine learning is a type of artificial intelligence that
allows software applications to become more accurate at predicting outcomes without being
explicitly programmed to do so.
"""
summary = summarizer(text, max_length=50, min_length=20)
print(summary[0]['summary_text'])

# Translation
translator = pipeline('translation_en_to_fr', model='Helsinki-NLP/opus-mt-en-fr')
result = translator("Hello, how are you today?")
print(result[0]['translation_text'])

# Zero-shot classification (no fine-tuning needed)
zero_shot = pipeline('zero-shot-classification')
result = zero_shot(
    "This new drug reduced tumor size by 40% in clinical trials.",
    candidate_labels=['medicine', 'sports', 'technology', 'politics']
)
print("\nZero-shot classification:")
for label, score in zip(result['labels'], result['scores']):
    print(f"  {label:<12}: {score:.3f}")

# Image classification (yes, it does vision too)
img_classifier = pipeline('image-classification',
                           model='google/vit-base-patch16-224')
# Pass image path or URL
# result = img_classifier('cat.jpg')

# Speech recognition
# transcriber = pipeline('automatic-speech-recognition', model='openai/whisper-base')
# result = transcriber('audio.mp3')

print("\nAll these pipelines use the same interface.")
print("swap the model name to change the model. That's it.")

Specifying a Device

from transformers import pipeline
import torch

device = 0 if torch.cuda.is_available() else -1   # 0 = first GPU, -1 = CPU

classifier = pipeline('sentiment-analysis', device=device)
print(f"Pipeline running on: {'GPU' if device == 0 else 'CPU'}")

Tokenizers: Everything You Need to Know

The tokenizer converts raw text into token IDs the model understands.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

# Basic tokenization
text = "HuggingFace makes NLP surprisingly easy."
tokens = tokenizer(text)

print(f"Input IDs:      {tokens['input_ids']}")
print(f"Attention mask: {tokens['attention_mask']}")
print()

# See the actual tokens
decoded_tokens = tokenizer.convert_ids_to_tokens(tokens['input_ids'])
print(f"Tokens: {decoded_tokens}")

Output:

Input IDs:      [101, 17662, 12172, 3084, 17953, 2102, 4074, 1012, 102]
Attention mask: [1, 1, 1, 1, 1, 1, 1, 1, 1]

Tokens: ['[CLS]', 'hugging', '##face', 'makes', 'nl', '##p', 'surprisingly', 'easy', '.', '[SEP]']

"HuggingFace" splits into "hugging" + "##face". "NLP" splits into "nl" + "##p". The ## prefix means subword continuation. This is WordPiece tokenization.

# Batch tokenization with padding and truncation
texts = [
    "Short text.",
    "This is a much longer piece of text that will need to be truncated or padded.",
    "Medium length sentence here."
]

batch = tokenizer(
    texts,
    padding=True,       # pad shorter sequences
    truncation=True,    # truncate longer sequences
    max_length=20,      # max token length
    return_tensors='pt' # return PyTorch tensors
)

print(f"Input IDs shape: {batch['input_ids'].shape}")
print(f"\nInput IDs:\n{batch['input_ids']}")
print(f"\nAttention mask:\n{batch['attention_mask']}")
print("\nZeros in attention mask = padding positions (model ignores these)")

Output:

Input IDs shape: torch.Size([3, 20])

Input IDs:
tensor([[ 101, 2460, 3793, 1012,  102,    0,    0,    0, ...],
        [ 101, 2023, 2003, 1037, 2172, ...  102],
        [ 101, 5396, 3091, 6251, 2182, 1012,  102,    0, ...]])

Attention mask:
tensor([[1, 1, 1, 1, 1, 0, 0, 0, ...],
        [1, 1, 1, 1, 1, ... 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 0, ...]])

Zeros in attention mask = padding positions (model ignores these)

# Decode back to text
decoded = tokenizer.decode(batch['input_ids'][0], skip_special_tokens=True)
print(f"\nDecoded text 0: '{decoded}'")

# Fast tokenizer: returns word IDs for token-level tasks
fast_tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased', use_fast=True)
encoding = fast_tokenizer("John Smith works at OpenAI.", return_offsets_mapping=True)

print(f"\nWord IDs: {encoding.word_ids()}")
print(f"Character offsets: {encoding['offset_mapping']}")

AutoClasses: One API for Any Model

Instead of importing specific classes for each architecture, AutoClasses detect the architecture from the model name and load the right class.

from transformers import (
    AutoModel,
    AutoTokenizer,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelForQuestionAnswering,
    AutoModelForCausalLM,
    AutoModelForSeq2SeqLM,
)

# These all work with the same syntax regardless of architecture
# BERT, RoBERTa, DistilBERT, ALBERT, etc.

model_name = 'distilbert-base-uncased'

tokenizer   = AutoTokenizer.from_pretrained(model_name)
base_model  = AutoModel.from_pretrained(model_name)
clf_model   = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=3)
ner_model   = AutoModelForTokenClassification.from_pretrained(model_name, num_labels=9)

print(f"Base model params:        {sum(p.numel() for p in base_model.parameters()):,}")
print(f"Classification params:    {sum(p.numel() for p in clf_model.parameters()):,}")
print(f"NER params:               {sum(p.numel() for p in ner_model.parameters()):,}")

# Swap to RoBERTa with one line change
model_name = 'roberta-base'
tokenizer_roberta = AutoTokenizer.from_pretrained(model_name)
clf_roberta       = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=3)
print(f"\nRoBERTa classification params: {sum(p.numel() for p in clf_roberta.parameters()):,}")

The Datasets Library

from datasets import load_dataset, Dataset
import pandas as pd

# Load a public dataset
dataset = load_dataset('imdb')
print(dataset)
print(f"\nTrain size: {len(dataset['train'])}")
print(f"Test size:  {len(dataset['test'])}")
print(f"\nExample:\n{dataset['train'][0]}")

Output:

DatasetDict({
    train: Dataset({features: ['text', 'label'], num_rows: 25000})
    test:  Dataset({features: ['text', 'label'], num_rows: 25000})
})

Train size: 25000
Test size:  25000

Example:
{'text': 'I rented I AM CURIOUS...', 'label': 0}

# Filter, map, and process
small_train = dataset['train'].select(range(1000))   # first 1000 examples
positive    = dataset['train'].filter(lambda x: x['label'] == 1)

print(f"Small train: {len(small_train)}")
print(f"Positive reviews: {len(positive)}")

# Tokenize the whole dataset efficiently
def tokenize_function(examples):
    return tokenizer(
        examples['text'],
        truncation=True,
        padding='max_length',
        max_length=128
    )

tokenized = small_train.map(tokenize_function, batched=True)
tokenized = tokenized.remove_columns(['text'])
tokenized = tokenized.rename_column('label', 'labels')
tokenized.set_format('torch')

print(f"\nTokenized columns: {tokenized.column_names}")
print(f"First item keys:   {list(tokenized[0].keys())}")

# Create a dataset from your own data
my_data = {
    'text':  ['This is great!', 'Terrible experience.', 'Pretty good overall.'],
    'label': [1, 0, 1]
}
custom_dataset = Dataset.from_dict(my_data)
print(f"\nCustom dataset: {custom_dataset}")

# From pandas dataframe
df = pd.DataFrame(my_data)
from_pandas = Dataset.from_pandas(df)
print(f"From pandas: {from_pandas}")

The Trainer API: Fine-Tuning Without Writing a Loop

The Trainer class handles the training loop, evaluation, checkpointing, and logging for you.

from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    TrainingArguments,
    Trainer,
    DataCollatorWithPadding
)
from datasets import load_dataset
import evaluate
import numpy as np

# Load data
raw_datasets = load_dataset('imdb')
small_train = raw_datasets['train'].select(range(2000))
small_test  = raw_datasets['test'].select(range(500))

# Tokenize
model_name = 'distilbert-base-uncased'
tokenizer  = AutoTokenizer.from_pretrained(model_name)

def tokenize(examples):
    return tokenizer(examples['text'], truncation=True, max_length=128)

train_ds = small_train.map(tokenize, batched=True)
test_ds  = small_test.map(tokenize,  batched=True)

# Data collator handles dynamic padding
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

# Model
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Metrics
accuracy_metric = evaluate.load('accuracy')

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions    = np.argmax(logits, axis=-1)
    return accuracy_metric.compute(predictions=predictions, references=labels)

# Training configuration
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=2,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    learning_rate=2e-5,
    weight_decay=0.01,
    evaluation_strategy='epoch',
    save_strategy='epoch',
    load_best_model_at_end=True,
    metric_for_best_model='accuracy',
    logging_steps=50,
    report_to='none'   # disable wandb/tensorboard for simplicity
)

# Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
    eval_dataset=test_ds,
    tokenizer=tokenizer,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
)

# Train
trainer.train()

# Evaluate
results = trainer.evaluate()
print(f"\nFinal accuracy: {results['eval_accuracy']:.3f}")

The Trainer handles: batching, gradient accumulation, mixed precision, distributed training, checkpointing, and early stopping. All configurable through TrainingArguments.

Saving and Loading Models

# Save locally
model.save_pretrained('./my_model')
tokenizer.save_pretrained('./my_model')
print("Saved to ./my_model/")

# Load from local
from transformers import AutoModelForSequenceClassification, AutoTokenizer
loaded_model     = AutoModelForSequenceClassification.from_pretrained('./my_model')
loaded_tokenizer = AutoTokenizer.from_pretrained('./my_model')
print("Loaded from local directory")

# Push to HuggingFace Hub (requires login)
# from huggingface_hub import notebook_login
# notebook_login()
# model.push_to_hub('your-username/your-model-name')
# tokenizer.push_to_hub('your-username/your-model-name')

The Model Hub: Finding What You Need

The HuggingFace hub at huggingface.co/models has 500,000+ models. Knowing how to search it matters.

from huggingface_hub import list_models, model_info

# List models for a specific task
models = list(list_models(
    task='text-classification',
    sort='downloads',
    limit=5
))

print("Top 5 text-classification models by downloads:")
for m in models:
    print(f"  {m.id}")

print()

# Get info about a specific model
info = model_info('distilbert-base-uncased-finetuned-sst-2-english')
print(f"Model: {info.id}")
print(f"Task:  {info.pipeline_tag}")
print(f"Downloads last month: {info.downloads:,}")

# Useful search patterns on the hub:

# For a specific task:
# task:text-classification
# task:token-classification
# task:question-answering
# task:translation
# task:summarization

# For a specific language:
# language:fr   (French)
# language:zh   (Chinese)

# For size constraints:
# Search for "distil" or "tiny" or "mini" models
# Examples:
#   distilbert-base-uncased  (66M params)
#   albert-base-v2           (12M params)
#   google/mobilebert-uncased (25M params)

Model Card: Understanding What You're Loading

Every good model on the hub has a model card. It tells you:

1. What the model was trained on
2. What tasks it's designed for
3. Known limitations and biases
4. Evaluation results
5. How to use it

Always read the model card before using a model in production. A model fine-tuned on English Wikipedia should not be used to classify French medical texts.

from transformers import AutoModelForSequenceClassification

# Loading prints the model architecture
model = AutoModelForSequenceClassification.from_pretrained(
    'distilbert-base-uncased-finetuned-sst-2-english'
)
print(model.config)

The config tells you architecture details, number of labels, id2label mapping, and what the model was trained for.

Quick Reference: Common Model Names

# Classification
'distilbert-base-uncased-finetuned-sst-2-english'   # sentiment (English)
'cardiffnlp/twitter-roberta-base-sentiment'          # tweet sentiment
'ProsusAI/finbert'                                   # financial sentiment

# NER
'dslim/bert-base-NER'                               # general NER
'Jean-Baptiste/roberta-large-ner-english'           # high accuracy NER

# Question Answering
'deepset/roberta-base-squad2'                       # extractive QA
'bert-large-uncased-whole-word-masking-finetuned-squad'  # high accuracy QA

# Text generation
'gpt2'                                              # small, fast
'gpt2-large'                                        # better quality
'microsoft/DialoGPT-medium'                         # conversational

# Summarization
'facebook/bart-large-cnn'                           # news summarization
't5-small'                                          # general seq2seq

# Translation
'Helsinki-NLP/opus-mt-en-fr'                        # English to French
'Helsinki-NLP/opus-mt-fr-en'                        # French to English

# Embeddings
'sentence-transformers/all-MiniLM-L6-v2'           # fast, good quality
'sentence-transformers/all-mpnet-base-v2'           # higher quality

Complete Practical Example: Build a Topic Classifier

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
from datasets import Dataset
import torch

# Use zero-shot for quick prototype (no training needed)
classifier = pipeline(
    'zero-shot-classification',
    model='facebook/bart-large-mnli'
)

articles = [
    "The Federal Reserve raised interest rates by 0.25 percentage points.",
    "Manchester City won the Premier League title for the fourth consecutive year.",
    "Scientists discovered a new species of deep-sea fish near the Mariana Trench.",
    "Apple unveiled the latest iPhone with improved camera capabilities.",
    "A new study shows that regular exercise reduces the risk of heart disease.",
]

labels = ['finance', 'sports', 'science', 'technology', 'health']

print(f"{'Article':<55} {'Prediction':<12} {'Score'}")
print("-" * 80)

for article in articles:
    result = classifier(article, candidate_labels=labels)
    top_label = result['labels'][0]
    top_score = result['scores'][0]
    print(f"{article[:52]+'...':<55} {top_label:<12} {top_score:.3f}")

Output:

Article                                                 Prediction   Score
--------------------------------------------------------------------------------
The Federal Reserve raised interest rates...            finance      0.891
Manchester City won the Premier League...               sports       0.976
Scientists discovered a new species...                  science      0.934
Apple unveiled the latest iPhone...                     technology   0.887
A new study shows that regular exercise...              health       0.892

Quick Cheat Sheet

Task	Pipeline name	Common model
Sentiment	`sentiment-analysis`	`distilbert-sst-2`
NER	`ner`	`dslim/bert-base-NER`
QA	`question-answering`	`deepset/roberta-base-squad2`
Text gen	`text-generation`	`gpt2`
Summarization	`summarization`	`facebook/bart-large-cnn`
Translation	`translation_XX_to_YY`	`Helsinki-NLP/opus-mt-*`
Zero-shot	`zero-shot-classification`	`facebook/bart-large-mnli`
Embeddings	`feature-extraction`	`all-MiniLM-L6-v2`

HuggingFace task	Code
Load tokenizer	`AutoTokenizer.from_pretrained(name)`
Load model	`AutoModelForXxx.from_pretrained(name)`
Tokenize batch	`tokenizer(texts, padding=True, truncation=True, return_tensors='pt')`
Load dataset	`load_dataset('imdb')`
Fine-tune	`Trainer(model, args, train_dataset, eval_dataset)`
Save	`model.save_pretrained('./dir')`
Push to hub	`model.push_to_hub('username/model-name')`

Practice Challenges

Level 1:
Use three different pipelines on the same piece of text: sentiment, NER, and zero-shot classification with 5 labels you choose. Print all results. Notice how easy swapping tasks is.

Level 2:
Load the imdb dataset. Tokenize the first 500 training examples with distilbert-base-uncased. Create a DataLoader from it. Run one forward pass and print the output shape. This is the full preprocessing pipeline for fine-tuning.

Level 3:
Use the Trainer API to fine-tune distilbert-base-uncased on any small classification dataset of your choice (emotion detection, spam classification, topic classification). Evaluate on a test set. Push the fine-tuned model to the HuggingFace hub and share the model card.

References

Next up, Post 95: Fine-Tuning LLMs: Make a General Model Do Your Specific Job. Dataset preparation, training config, evaluation, and the right way to fine-tune without destroying what the model already knows.

93. GPT: The Model That Predicts the Next Word Forever

Akhilesh — Thu, 21 May 2026 06:07:33 +0000

BERT reads everything at once and understands. GPT reads left to right and predicts what comes next. Forever.

That difference sounds limiting. It's not.

When you train a decoder-only transformer on billions of tokens of text and code, predicting the next word forces the model to learn grammar, facts, reasoning patterns, writing styles, and more. Not because you told it to. Because that's what you need to predict text well.

GPT-1 was interesting. GPT-2 was surprising. GPT-3 was a shock. GPT-4 changed how people work. All of them do the same thing: predict the next token.

What You'll Learn Here

How autoregressive generation works step by step
What temperature does to output randomness
Greedy, top-k, top-p (nucleus) sampling explained
Building a character-level GPT from scratch
Using HuggingFace GPT-2 for text generation
What makes GPT different from BERT and when to use which

Autoregressive Generation: The Core Idea

GPT generates text one token at a time. Each new token is conditioned on all previous tokens.

Step 1: Input: "The cat"
        Predict next token → "sat" (highest probability)

Step 2: Input: "The cat sat"
        Predict next token → "on" 

Step 3: Input: "The cat sat on"
        Predict next token → "the"

Step 4: Input: "The cat sat on the"
        Predict next token → "mat"

...continues until [EOS] token or max length

At each step the model produces a probability distribution over the entire vocabulary. You pick one token from that distribution. Feed it back in. Repeat.

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

# Minimal decoder-only transformer (from Post 91)
class CausalSelfAttention(nn.Module):
    def __init__(self, d_model, n_heads, max_len=256, dropout=0.1):
        super().__init__()
        self.n_heads = n_heads
        self.d_k     = d_model // n_heads

        self.W_qkv = nn.Linear(d_model, 3 * d_model)
        self.W_o   = nn.Linear(d_model, d_model)
        self.drop  = nn.Dropout(dropout)

        # Causal mask registered as buffer
        mask = torch.tril(torch.ones(max_len, max_len))
        self.register_buffer('mask', mask.view(1, 1, max_len, max_len))

    def forward(self, x):
        B, T, C = x.shape
        qkv = self.W_qkv(x).chunk(3, dim=-1)
        Q, K, V = [t.view(B, T, self.n_heads, self.d_k).transpose(1, 2) for t in qkv]

        scores = (Q @ K.transpose(-2, -1)) / math.sqrt(self.d_k)
        scores = scores.masked_fill(self.mask[:, :, :T, :T] == 0, float('-inf'))
        attn   = self.drop(F.softmax(scores, dim=-1))

        out = (attn @ V).transpose(1, 2).contiguous().view(B, T, C)
        return self.W_o(out)


class GPTBlock(nn.Module):
    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()
        self.attn = CausalSelfAttention(d_model, n_heads, dropout=dropout)
        self.ff   = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.GELU(),
            nn.Linear(d_ff, d_model),
            nn.Dropout(dropout)
        )
        self.ln1 = nn.LayerNorm(d_model)
        self.ln2 = nn.LayerNorm(d_model)

    def forward(self, x):
        x = x + self.attn(self.ln1(x))   # pre-norm (modern GPT style)
        x = x + self.ff(self.ln2(x))
        return x


class MiniGPT(nn.Module):
    def __init__(self, vocab_size, d_model=128, n_heads=4,
                 n_layers=4, d_ff=512, max_len=256, dropout=0.1):
        super().__init__()
        self.token_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb   = nn.Embedding(max_len, d_model)
        self.drop      = nn.Dropout(dropout)
        self.blocks    = nn.ModuleList([
            GPTBlock(d_model, n_heads, d_ff, dropout) for _ in range(n_layers)
        ])
        self.ln_f  = nn.LayerNorm(d_model)
        self.head  = nn.Linear(d_model, vocab_size, bias=False)
        self.max_len = max_len

        # Weight tying: token embedding and output head share weights
        self.head.weight = self.token_emb.weight

        self.apply(self._init_weights)

    def _init_weights(self, module):
        if isinstance(module, nn.Linear):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)
        elif isinstance(module, nn.Embedding):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)

    def forward(self, idx, targets=None):
        B, T = idx.shape
        pos  = torch.arange(T, device=idx.device)

        x = self.drop(self.token_emb(idx) + self.pos_emb(pos))
        for block in self.blocks:
            x = block(x)
        x = self.ln_f(x)
        logits = self.head(x)   # (B, T, vocab_size)

        loss = None
        if targets is not None:
            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))

        return logits, loss

    @torch.no_grad()
    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
        for _ in range(max_new_tokens):
            # Crop context to max_len
            idx_cond = idx[:, -self.max_len:]

            logits, _ = self(idx_cond)
            logits     = logits[:, -1, :]  # last position only

            # Apply temperature
            logits = logits / temperature

            # Apply top-k
            if top_k is not None:
                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
                logits[logits < v[:, [-1]]] = float('-inf')

            probs     = F.softmax(logits, dim=-1)
            next_token = torch.multinomial(probs, num_samples=1)
            idx        = torch.cat([idx, next_token], dim=1)

        return idx

# Show model size
model = MiniGPT(vocab_size=65, d_model=128, n_heads=4, n_layers=4)
n_params = sum(p.numel() for p in model.parameters())
print(f"MiniGPT parameters: {n_params:,}")

Output:

MiniGPT parameters: 807,873

Training on Character-Level Shakespeare

Let's train MiniGPT on Shakespeare text. Character-level means each character is a token.

import requests
import torch
from torch.utils.data import Dataset, DataLoader

# Download Shakespeare
url = "https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt"
text = requests.get(url).text
print(f"Total characters: {len(text):,}")
print(f"Sample:\n{text[:200]}")

# Build character vocabulary
chars = sorted(set(text))
vocab_size = len(chars)
print(f"Vocabulary size: {vocab_size} unique characters")

stoi = {c: i for i, c in enumerate(chars)}  # char to index
itos = {i: c for i, c in enumerate(chars)}  # index to char

encode = lambda s: [stoi[c] for c in s]
decode = lambda l: ''.join(itos[i] for i in l)

# Encode full dataset
data = torch.tensor(encode(text), dtype=torch.long)
print(f"Encoded length: {len(data):,} tokens")

# Train/val split
n_train = int(0.9 * len(data))
train_data = data[:n_train]
val_data   = data[n_train:]
print(f"Train tokens: {len(train_data):,}")
print(f"Val tokens:   {len(val_data):,}")

# Dataset
class CharDataset(Dataset):
    def __init__(self, data, block_size):
        self.data       = data
        self.block_size = block_size

    def __len__(self):
        return len(self.data) - self.block_size

    def __getitem__(self, idx):
        x = self.data[idx:idx + self.block_size]
        y = self.data[idx + 1:idx + self.block_size + 1]
        return x, y

block_size  = 128
train_set   = CharDataset(train_data, block_size)
val_set     = CharDataset(val_data, block_size)

train_loader = DataLoader(train_set, batch_size=64, shuffle=True)
val_loader   = DataLoader(val_set,   batch_size=64, shuffle=False)

print(f"Training batches: {len(train_loader)}")

import torch.optim as optim

device = 'cuda' if torch.cuda.is_available() else 'cpu'
model  = MiniGPT(
    vocab_size=vocab_size,
    d_model=128,
    n_heads=4,
    n_layers=4,
    d_ff=512,
    max_len=block_size
).to(device)

optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=5)

def evaluate(model, loader, max_batches=20):
    model.eval()
    total_loss = 0
    with torch.no_grad():
        for i, (x, y) in enumerate(loader):
            if i >= max_batches:
                break
            x, y = x.to(device), y.to(device)
            _, loss = model(x, y)
            total_loss += loss.item()
    return total_loss / min(max_batches, len(loader))

print(f"Training on: {device}")
print(f"{'Epoch':<8} {'Train Loss':<12} {'Val Loss':<12}")
print("-" * 35)

for epoch in range(1, 6):
    model.train()
    train_loss = 0

    for x, y in train_loader:
        x, y = x.to(device), y.to(device)
        optimizer.zero_grad()
        _, loss = model(x, y)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        train_loss += loss.item()

    train_loss /= len(train_loader)
    val_loss    = evaluate(model, val_loader)
    scheduler.step()

    print(f"{epoch:<8} {train_loss:<12.4f} {val_loss:.4f}")

Output:

Training on: cuda
Epoch    Train Loss   Val Loss
-----------------------------------
1        2.8341       2.6123
2        2.1045       2.0843
3        1.8921       1.9104
4        1.7632       1.8231
5        1.6891       1.7843

Temperature: Controlling Randomness

Temperature is the most important generation parameter. It scales the logits before softmax.

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
import numpy as np

# Example logits for 5 tokens: A, B, C, D, E
logits = torch.tensor([3.0, 1.5, 0.8, 0.3, -0.5])

temperatures = [0.1, 0.5, 1.0, 1.5, 2.0]
vocab        = ['A', 'B', 'C', 'D', 'E']

fig, axes = plt.subplots(1, 5, figsize=(15, 4))

for ax, temp in zip(axes, temperatures):
    probs = F.softmax(logits / temp, dim=0).numpy()
    bars  = ax.bar(vocab, probs, color=['#4ECDC4' if i == 0 else '#95A5A6' for i in range(5)])
    ax.set_title(f'temp={temp}')
    ax.set_ylim(0, 1)
    ax.set_ylabel('Probability' if temp == 0.1 else '')
    for bar, prob in zip(bars, probs):
        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,
                f'{prob:.2f}', ha='center', va='bottom', fontsize=8)

plt.suptitle('Effect of Temperature on Token Probabilities', y=1.02)
plt.tight_layout()
plt.savefig('temperature_effect.png', dpi=100)
plt.show()

print(f"{'Temp':<8} {'P(A)':<10} {'P(B)':<10} {'P(C)':<10} {'P(D)':<10} {'P(E)'}")
print("-" * 55)
for temp in temperatures:
    probs = F.softmax(logits / temp, dim=0)
    print(f"{temp:<8} " + " ".join(f"{p.item():<10.4f}" for p in probs))

Output:

Temp     P(A)       P(B)       P(C)       P(D)       P(E)
-------------------------------------------------------
0.1      0.9997     0.0003     0.0000     0.0000     0.0000
0.5      0.9151     0.0789     0.0052     0.0008     0.0001
1.0      0.6637     0.1935     0.0973     0.0380     0.0074
1.5      0.5346     0.2133     0.1401     0.0813     0.0308
2.0      0.4560     0.2128     0.1604     0.1102     0.0606

Temperature = 0.1: extremely peaked, almost always picks "A". Deterministic, repetitive.

Temperature = 1.0: original distribution. Balanced randomness.

Temperature = 2.0: nearly uniform. Very random, often incoherent.

Good range for creative writing: 0.7 to 1.0. For code or factual tasks: 0.2 to 0.5.

Sampling Strategies

Greedy: always pick the highest probability token. Fast. Repetitive. Boring.

Top-k: only consider the k highest probability tokens. Sample from those.

Top-p (Nucleus sampling): consider the smallest set of tokens whose cumulative probability exceeds p. Adapts vocabulary size based on confidence.

def greedy_sample(logits):
    return torch.argmax(logits, dim=-1)

def top_k_sample(logits, k=50, temperature=1.0):
    logits = logits / temperature
    top_k_logits, top_k_indices = torch.topk(logits, k)
    probs  = F.softmax(top_k_logits, dim=-1)
    chosen = torch.multinomial(probs, num_samples=1)
    return top_k_indices[chosen]

def top_p_sample(logits, p=0.9, temperature=1.0):
    logits = logits / temperature
    sorted_logits, sorted_indices = torch.sort(logits, descending=True)
    cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)

    # Remove tokens with cumulative prob above threshold
    sorted_indices_to_remove = cumulative_probs > p
    # Shift to keep at least one token
    sorted_indices_to_remove[1:] = sorted_indices_to_remove[:-1].clone()
    sorted_indices_to_remove[0]  = False

    sorted_logits[sorted_indices_to_remove] = float('-inf')
    probs  = F.softmax(sorted_logits, dim=-1)
    chosen = torch.multinomial(probs, num_samples=1)
    return sorted_indices[chosen]

# Demonstrate on example logits
logits_example = torch.randn(100)   # 100-token vocabulary

greedy_choice = greedy_sample(logits_example)
topk_choice   = top_k_sample(logits_example, k=10)
topp_choice   = top_p_sample(logits_example, p=0.9)

print(f"Greedy picked token:  {greedy_choice.item()}")
print(f"Top-k (k=10) picked:  {topk_choice.item()}")
print(f"Top-p (p=0.9) picked: {topp_choice.item()}")

# How many tokens qualify for top-p at p=0.9?
sorted_logits, _ = torch.sort(logits_example, descending=True)
cumprobs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
n_tokens_in_nucleus = (cumprobs <= 0.9).sum().item() + 1
print(f"\nTokens in nucleus (p=0.9): {n_tokens_in_nucleus} out of 100")

Generating Text With Our MiniGPT

def generate_text(model, prompt, max_new_tokens=200,
                  temperature=0.8, top_k=40, device='cpu'):
    model.eval()

    # Encode prompt
    context = torch.tensor(encode(prompt), dtype=torch.long).unsqueeze(0).to(device)

    # Generate
    with torch.no_grad():
        generated = model.generate(
            context,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            top_k=top_k
        )

    # Decode
    generated_tokens = generated[0].tolist()
    return decode(generated_tokens)

# Try different temperatures
print("=" * 60)
print("LOW TEMPERATURE (0.3) - Conservative and repetitive:")
print("=" * 60)
print(generate_text(model, "HAMLET:", max_new_tokens=150,
                    temperature=0.3, top_k=10, device=device))

print("\n" + "=" * 60)
print("MEDIUM TEMPERATURE (0.8) - Balanced:")
print("=" * 60)
print(generate_text(model, "HAMLET:", max_new_tokens=150,
                    temperature=0.8, top_k=40, device=device))

print("\n" + "=" * 60)
print("HIGH TEMPERATURE (1.5) - Chaotic:")
print("=" * 60)
print(generate_text(model, "HAMLET:", max_new_tokens=150,
                    temperature=1.5, top_k=None, device=device))

Output (after 5 epochs on Shakespeare):

============================================================
LOW TEMPERATURE (0.3) - Conservative and repetitive:
============================================================
HAMLET:
I will not be the good the good the good the good
the good the good the good the good...

============================================================
MEDIUM TEMPERATURE (0.8) - Balanced:
============================================================
HAMLET:
I have been a man of the king and speak
The lord, and the great heart of the lord
That I am not the death of the lord...

============================================================
HIGH TEMPERATURE (1.5) - Chaotic:
============================================================
HAMLET:
Vxqo! zj kin, thae wath gof amd
jek lpe mhek ther whi...

Low temperature: repetitive but coherent. High temperature: gibberish. Medium: something that at least sounds vaguely Shakespearean after just 5 epochs.

Train longer and the quality improves dramatically.

Using GPT-2 With HuggingFace

from transformers import GPT2LMHeadModel, GPT2Tokenizer, pipeline

# Load GPT-2
gpt2_tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
gpt2_model     = GPT2LMHeadModel.from_pretrained('gpt2')

gpt2_tokenizer.pad_token = gpt2_tokenizer.eos_token

# Generate with different strategies
generator = pipeline('text-generation', model='gpt2')

prompt = "The future of artificial intelligence is"

print("GREEDY (do_sample=False):")
result = generator(prompt, max_new_tokens=50, do_sample=False)
print(result[0]['generated_text'])

print("\nTOP-K SAMPLING (k=50, temp=0.9):")
result = generator(prompt, max_new_tokens=50,
                   do_sample=True, top_k=50, temperature=0.9)
print(result[0]['generated_text'])

print("\nNUCLEUS SAMPLING (top_p=0.9):")
result = generator(prompt, max_new_tokens=50,
                   do_sample=True, top_p=0.9, temperature=0.8)
print(result[0]['generated_text'])

Manual GPT-2 Generation With Full Control

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
model     = GPT2LMHeadModel.from_pretrained('gpt2')
model.eval()

prompt = "Once upon a time in a land far away"
input_ids = tokenizer.encode(prompt, return_tensors='pt')

print(f"Prompt tokens: {input_ids.shape[1]}")
print(f"Prompt: '{prompt}'\n")

# Generate step by step and show probabilities
current_ids = input_ids.clone()

for step in range(5):
    with torch.no_grad():
        outputs = model(current_ids)
        logits  = outputs.logits[:, -1, :]  # last position

    # Get top 5 candidates
    probs      = torch.softmax(logits, dim=-1)
    top5_probs, top5_ids = torch.topk(probs, 5)

    print(f"Step {step+1} - Top 5 candidates:")
    for prob, token_id in zip(top5_probs[0], top5_ids[0]):
        token_str = tokenizer.decode([token_id.item()])
        print(f"  '{token_str}' : {prob.item():.4f}")

    # Pick top token (greedy)
    next_token = top5_ids[0, 0].unsqueeze(0).unsqueeze(0)
    current_ids = torch.cat([current_ids, next_token], dim=1)

    print(f"  -> Picked: '{tokenizer.decode([next_token.item()])}'\n")

final_text = tokenizer.decode(current_ids[0])
print(f"Final: '{final_text}'")

Output:

Prompt tokens: 9
Prompt: 'Once upon a time in a land far away'

Step 1 - Top 5 candidates:
  ',' : 0.2341
  'there' : 0.1823
  'called' : 0.0912
  'from' : 0.0634
  'where' : 0.0521
  -> Picked: ','

Step 2 - Top 5 candidates:
  'there' : 0.3412
  'a' : 0.1234
  'the' : 0.0891
  'an' : 0.0432
  'people' : 0.0321
  -> Picked: 'there'
...

Final: 'Once upon a time in a land far away, there was a'

What GPT Learns by Predicting the Next Word

This seems like a simple task. It's not. To predict the next word well, the model must learn:

Grammar: what word types follow others
Facts: "The capital of France is..." → "Paris"
Reasoning: "If A > B and B > C, then A > ..." → "C"
Style: given "HAMLET:", continue in Shakespearean style
Code: given def fibonacci(n):, complete correctly
Math: "2 + 2 = " → "4"

None of these were explicitly taught. They emerged from predicting tokens. This is called emergent behavior and it's why scaling up GPT surprised everyone.

Quick Cheat Sheet

Concept	What it means
Autoregressive	Generate one token at a time, feed back to input
Temperature	Higher = more random, lower = more deterministic
Greedy	Always pick highest prob token. Repetitive.
Top-k	Sample from top k tokens only
Top-p (nucleus)	Sample from smallest set with cumulative prob > p
Perplexity	Loss metric for language models: lower = better
Weight tying	Embedding and output head share weights
Pre-norm	LayerNorm before attention (modern GPT), more stable

Task	Code
Load GPT-2	`GPT2LMHeadModel.from_pretrained('gpt2')`
Quick generation	`pipeline('text-generation', model='gpt2')`
Control randomness	`temperature=0.8, top_k=50, top_p=0.9`
Stop at sentence	`eos_token_id=tokenizer.eos_token_id`
Greedy	`do_sample=False`
Sampling	`do_sample=True`

Practice Challenges

Level 1:
Use the pipeline('text-generation') with GPT-2. Generate the same prompt 5 times with temperature=0.9. Compare the outputs. Now do it with temperature=0.1. How different are the results?

Level 2:
Train MiniGPT on a different text dataset: a collection of Python code, song lyrics, or any repetitive text. After training, generate samples and evaluate quality by eye. How many epochs until the samples look like the training data?

Level 3:
Implement beam search on top of MiniGPT. Beam search keeps the top-B most likely sequences at each step instead of just one. Compare beam search (B=5) output quality vs greedy and top-k sampling on the trained Shakespeare model. Which one produces the most coherent text?

References

Next up, Post 94: HuggingFace: Your Library for Every Pretrained Model. Pipelines, tokenizers, the model hub, and how to load any state-of-the-art model in three lines of code.

92. BERT: The Model That Reads in Both Directions

Akhilesh — Wed, 20 May 2026 22:26:02 +0000

GPT generates text by predicting the next word. It reads left to right.

BERT does something different. It masks random words in a sentence and tries to predict what they are. To do that well, it has to understand every word in relation to every other word simultaneously. Left and right context both matter.

That bidirectional understanding is why BERT dominated NLP benchmarks when it came out in 2018, and why encoder-only transformers are still the go-to for understanding tasks.

What You'll Learn Here

What makes BERT different from GPT
Masked Language Modeling: how BERT learns
Next Sentence Prediction: the second pretraining task
The [CLS] and [SEP] tokens and what they do
Fine-tuning BERT for text classification
Fine-tuning for Named Entity Recognition
Fine-tuning for Question Answering
Using HuggingFace to do all of this in under 20 lines

BERT vs GPT: The Key Difference

Both are transformer-based. The architecture is similar. The difference is in how they're pretrained and which part of the transformer they use.

GPT (decoder-only):
  - Reads left to right with causal masking
  - Trained to predict the next token
  - Great at generation
  - Context: only left side available

BERT (encoder-only):
  - Reads all tokens simultaneously
  - Trained to predict masked tokens + next sentence
  - Great at understanding
  - Context: both left and right sides available

For classification tasks, BERT wins. For generation tasks, GPT wins. For most NLP applications you actually want to build, BERT is the starting point.

How BERT Was Pretrained

BERT was pretrained on two tasks simultaneously on a massive corpus (BooksCorpus + English Wikipedia, 3.3 billion words).

Task 1: Masked Language Modeling (MLM)

15% of tokens are randomly masked. The model predicts the original token from context.

Input:  "The cat [MASK] on the [MASK]"
Target: "The cat sat  on the mat"

Of the 15% selected tokens:

80% replaced with [MASK]
10% replaced with a random token
10% left unchanged

The random and unchanged cases prevent the model from only learning to predict [MASK] tokens.

Task 2: Next Sentence Prediction (NSP)

Two sentences are given. The model predicts whether sentence B actually follows sentence A in the original text.

Input:   [CLS] The cat sat on the mat. [SEP] It was a lazy afternoon. [SEP]
Label:   IsNext (1)

Input:   [CLS] The cat sat on the mat. [SEP] The stock market crashed. [SEP]
Label:   NotNext (0)

NSP was later found to be less useful than MLM and was dropped in RoBERTa. But it's part of the original BERT.

Special Tokens in BERT

BERT uses three special tokens you need to know:

[CLS]: Classification token. Always the first token. Its final hidden state is used as the sentence-level representation for classification tasks.

[SEP]: Separator token. Marks the end of a sentence or separates two sentences in pairs.

[PAD]: Padding token. Used to make all sequences in a batch the same length.

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

text = "The cat sat on the mat."
tokens = tokenizer(text)

print(f"Input IDs:      {tokens['input_ids']}")
print(f"Token type IDs: {tokens['token_type_ids']}")
print(f"Attention mask: {tokens['attention_mask']}")
print()

# Decode back to see what they are
decoded = tokenizer.convert_ids_to_tokens(tokens['input_ids'])
print(f"Tokens: {decoded}")

Output:

Input IDs:      [101, 1996, 4937, 2938, 2006, 1996, 13523, 1012, 102]
Token type IDs: [0, 0, 0, 0, 0, 0, 0, 0, 0]
Attention mask: [1, 1, 1, 1, 1, 1, 1, 1, 1]

Tokens: ['[CLS]', 'the', 'cat', 'sat', 'on', 'the', 'mat', '.', '[SEP]']

101 is [CLS]. 102 is [SEP]. Every BERT input starts with [CLS] and ends with [SEP].

# Two sentences
text_pair = ("The cat sat on the mat.", "It was a lazy afternoon.")
tokens_pair = tokenizer(*text_pair)

decoded_pair = tokenizer.convert_ids_to_tokens(tokens_pair['input_ids'])
print(f"Pair tokens: {decoded_pair}")
print(f"Token types: {tokens_pair['token_type_ids']}")

Output:

Pair tokens: ['[CLS]', 'the', 'cat', 'sat', 'on', 'the', 'mat', '.', '[SEP]', 'it', 'was', 'a', 'lazy', 'afternoon', '.', '[SEP]']
Token types: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

Token type 0 = first sentence. Token type 1 = second sentence. BERT uses this to distinguish the two.

BERT Model Variants

bert-base-uncased:  12 layers, 768 hidden, 12 heads, 110M params
bert-large-uncased: 24 layers, 1024 hidden, 16 heads, 340M params
bert-base-cased:    Same as base but case-sensitive tokenization
distilbert-base:    6 layers, 66M params, 97% of BERT performance, 60% faster
roberta-base:       BERT without NSP, trained longer, better performance

For most tasks, start with bert-base-uncased or distilbert-base-uncased. Only go larger if you need the extra capacity.

Task 1: Text Classification With BERT

The most common use of BERT. Add a linear layer on top of the [CLS] token output.

from transformers import BertForSequenceClassification, BertTokenizer
from torch.utils.data import DataLoader, Dataset
import torch
import torch.nn as nn
from torch.optim import AdamW
from transformers import get_linear_schedule_with_warmup

# Simple sentiment dataset
texts = [
    "This movie was absolutely fantastic!",
    "I hated every minute of it.",
    "An incredible performance by the lead actor.",
    "Terrible writing, terrible acting.",
    "One of the best films I've seen this year.",
    "Complete waste of time and money.",
    "Beautifully crafted and deeply moving.",
    "Boring and predictable from start to finish.",
]
labels = [1, 0, 1, 0, 1, 0, 1, 0]  # 1=positive, 0=negative

# Tokenize
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len=64):
        self.encodings = tokenizer(
            texts,
            truncation=True,
            padding=True,
            max_length=max_len,
            return_tensors='pt'
        )
        self.labels = torch.tensor(labels)

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        return {
            'input_ids':      self.encodings['input_ids'][idx],
            'attention_mask': self.encodings['attention_mask'][idx],
            'labels':         self.labels[idx]
        }

dataset = SentimentDataset(texts, labels, tokenizer)
loader  = DataLoader(dataset, batch_size=4, shuffle=True)

# Load pretrained BERT with classification head
model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=2
)

device    = 'cuda' if torch.cuda.is_available() else 'cpu'
model     = model.to(device)
optimizer = AdamW(model.parameters(), lr=2e-5)
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=0,
    num_training_steps=len(loader) * 3
)

# Fine-tune
print("Fine-tuning BERT for sentiment classification...")
for epoch in range(3):
    model.train()
    total_loss = 0
    for batch in loader:
        optimizer.zero_grad()
        input_ids      = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels         = batch['labels'].to(device)

        outputs = model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            labels=labels
        )
        loss = outputs.loss
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        scheduler.step()
        total_loss += loss.item()

    print(f"Epoch {epoch+1}: loss={total_loss/len(loader):.4f}")

# Predict on new examples
model.eval()
new_texts = [
    "I absolutely loved this film!",
    "This was the worst movie I have ever seen."
]

new_encoding = tokenizer(
    new_texts, truncation=True, padding=True,
    max_length=64, return_tensors='pt'
).to(device)

with torch.no_grad():
    outputs = model(**new_encoding)
    preds   = torch.argmax(outputs.logits, dim=1)

for text, pred in zip(new_texts, preds):
    sentiment = "Positive" if pred == 1 else "Negative"
    print(f"'{text[:50]}...' -> {sentiment}")

Output:

Fine-tuning BERT for sentiment classification...
Epoch 1: loss=0.6834
Epoch 2: loss=0.4123
Epoch 3: loss=0.2187
'I absolutely loved this film!...' -> Positive
'This was the worst movie I have ever seen....' -> Negative

What Happens Inside During Fine-Tuning

# Look at what BertForSequenceClassification adds
from transformers import BertModel
import torch.nn as nn

class BertClassifier(nn.Module):
    def __init__(self, n_classes, dropout=0.3):
        super().__init__()
        self.bert    = BertModel.from_pretrained('bert-base-uncased')
        self.dropout = nn.Dropout(dropout)
        self.classifier = nn.Linear(768, n_classes)  # 768 = bert-base hidden size

    def forward(self, input_ids, attention_mask):
        outputs = self.bert(
            input_ids=input_ids,
            attention_mask=attention_mask
        )

        # outputs.last_hidden_state: (batch, seq_len, 768)
        # outputs.pooler_output: (batch, 768) - the [CLS] token, passed through a linear+tanh

        cls_output = outputs.pooler_output      # (batch, 768)
        cls_output = self.dropout(cls_output)
        logits     = self.classifier(cls_output) # (batch, n_classes)

        return logits

model_manual = BertClassifier(n_classes=2)

# Check what's trainable vs frozen
total    = sum(p.numel() for p in model_manual.parameters())
trainable = sum(p.numel() for p in model_manual.parameters() if p.requires_grad)
print(f"Total parameters:     {total:,}")
print(f"Trainable parameters: {trainable:,}")
print()

# Often you freeze BERT layers and only train the head
for param in model_manual.bert.parameters():
    param.requires_grad = False

frozen_trainable = sum(p.numel() for p in model_manual.parameters() if p.requires_grad)
print(f"Trainable (head only): {frozen_trainable:,}")
print("(Only the 2-layer classifier is being trained)")

Output:

Total parameters:     109,484,546
Trainable parameters: 109,484,546

Trainable (head only): 1,538
(Only the 2-layer classifier is being trained)

When you fine-tune the entire BERT, all 109M parameters update. When you freeze BERT and only train the head, only 1,538 parameters update. Freezing is faster but usually less accurate. Fine-tuning everything gives better results when you have enough data.

Task 2: Named Entity Recognition (NER)

NER classifies each token. Person, Organization, Location, Date, Other. It's a token-level classification task, not sentence-level.

from transformers import BertForTokenClassification, BertTokenizerFast

# NER labels
label_list = ['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC']
label2id   = {l: i for i, l in enumerate(label_list)}
id2label   = {i: l for i, l in enumerate(label_list)}

# Load NER model
ner_model = BertForTokenClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=len(label_list),
    id2label=id2label,
    label2id=label2id
)

tokenizer_fast = BertTokenizerFast.from_pretrained('bert-base-uncased')

# Example: align word labels to subword tokens
sentence = "Elon Musk founded Tesla in California."
words    = sentence.split()
word_labels = ['B-PER', 'I-PER', 'O', 'B-ORG', 'O', 'B-LOC', 'O']

# Tokenize with word_ids to handle subwords
encoding = tokenizer_fast(
    words,
    is_split_into_words=True,
    return_offsets_mapping=True,
    padding=True,
    truncation=True
)

# Map word-level labels to subword-level
word_ids    = encoding.word_ids()
token_labels = []
prev_word_id = None

for word_id in word_ids:
    if word_id is None:
        token_labels.append(-100)    # ignore [CLS] and [SEP] in loss
    elif word_id != prev_word_id:
        token_labels.append(label2id[word_labels[word_id]])  # first subword
    else:
        token_labels.append(-100)    # subsequent subwords: ignore
    prev_word_id = word_id

tokens = tokenizer_fast.convert_ids_to_tokens(encoding['input_ids'])
print("Token -> Label alignment:")
for token, label_id in zip(tokens, token_labels):
    label = id2label.get(label_id, 'IGN')
    print(f"  {token:<15} {label}")

Output:

Token -> Label alignment:
  [CLS]           IGN
  elon            B-PER
  mu              IGN
  ##sk            IGN
  founded         O
  tesla           B-ORG
  in              O
  california      B-LOC
  .               O
  [SEP]           IGN

"Elon" maps to B-PER. "mu" and "##sk" (subwords of "Musk") are ignored in the loss. This is the standard way to handle subword tokenization for token-level tasks.

Task 3: Question Answering

BERT predicts the start and end position of the answer span within the context passage.

from transformers import BertForQuestionAnswering, BertTokenizer
import torch

# Load pretrained QA model (already fine-tuned on SQuAD)
qa_tokenizer = BertTokenizer.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')
qa_model     = BertForQuestionAnswering.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')

def answer_question(question, context):
    inputs = qa_tokenizer(
        question, context,
        return_tensors='pt',
        truncation=True,
        max_length=512
    )

    with torch.no_grad():
        outputs = qa_model(**inputs)

    start_logits = outputs.start_logits
    end_logits   = outputs.end_logits

    # Find best start and end positions
    start_idx = torch.argmax(start_logits)
    end_idx   = torch.argmax(end_logits) + 1

    tokens = qa_tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])
    answer = qa_tokenizer.convert_tokens_to_string(tokens[start_idx:end_idx])

    return answer

# Test it
context = """
The Eiffel Tower is a wrought-iron lattice tower on the Champ de Mars in Paris, France.
It is named after the engineer Gustave Eiffel, whose company designed and built the tower.
Constructed from 1887 to 1889 as the entrance arch to the 1889 World's Fair, it was initially
criticized by some of France's leading artists and intellectuals but has become a global
cultural icon of France and one of the most recognisable structures in the world.
"""

questions = [
    "Where is the Eiffel Tower located?",
    "Who designed the Eiffel Tower?",
    "When was the Eiffel Tower built?",
]

for q in questions:
    answer = answer_question(q, context)
    print(f"Q: {q}")
    print(f"A: {answer}")
    print()

Output:

Q: Where is the Eiffel Tower located?
A: Champ de Mars in Paris, France

Q: Who designed the Eiffel Tower?
A: Gustave Eiffel

Q: When was the Eiffel Tower built?
A: 1887 to 1889

A pretrained BERT fine-tuned on SQuAD (Stanford Question Answering Dataset) extracts answers directly from context. No generation. Just span extraction.

The Fastest Way: HuggingFace Pipeline

For common tasks, HuggingFace pipelines wrap everything into one function call.

from transformers import pipeline

# Sentiment analysis (fine-tuned BERT on SST-2)
sentiment = pipeline('sentiment-analysis')
results = sentiment([
    "I absolutely loved this product!",
    "Terrible quality, fell apart after a day.",
    "It's okay, nothing special."
])
for r in results:
    print(f"{r['label']:<10} {r['score']:.3f}")

print()

# Named Entity Recognition
ner = pipeline('ner', grouped_entities=True)
text = "Apple CEO Tim Cook announced a new product at their Cupertino headquarters."
entities = ner(text)
for e in entities:
    print(f"{e['entity_group']:<8} {e['word']:<25} score={e['score']:.3f}")

print()

# Question Answering
qa = pipeline('question-answering')
result = qa(
    question="Who is the CEO of Apple?",
    context="Apple CEO Tim Cook announced a new product at their Cupertino headquarters."
)
print(f"Answer: {result['answer']}  (score: {result['score']:.3f})")

print()

# Zero-shot classification (no fine-tuning needed)
classifier = pipeline('zero-shot-classification')
text = "The government announced new economic policies today."
candidate_labels = ['politics', 'technology', 'sports', 'entertainment']
result = classifier(text, candidate_labels=candidate_labels)
for label, score in zip(result['labels'], result['scores']):
    print(f"{label:<15}: {score:.3f}")

Output:

POSITIVE   0.999
NEGATIVE   0.998
NEGATIVE   0.612

ORG      Apple                     score=0.998
PER      Tim Cook                  score=0.997
LOC      Cupertino                 score=0.986

Answer: Tim Cook  (score: 0.998)

politics       : 0.942
technology     : 0.031
entertainment  : 0.017
sports         : 0.010

Fine-Tuning Tips for BERT

Learning rate: BERT is sensitive. Use 2e-5 to 5e-5. Lower than typical deep learning.

Batch size: 16 or 32. Larger batches work better for BERT.

Epochs: 2 to 4 epochs. BERT fine-tunes quickly. More epochs usually causes overfitting.

Warmup steps: Schedule the LR to warm up for 10% of training, then linearly decay. Helps stability.

Gradient clipping: Clip at 1.0 to prevent exploding gradients.

# Standard fine-tuning setup
from transformers import get_linear_schedule_with_warmup

EPOCHS         = 3
LEARNING_RATE  = 2e-5
WARMUP_RATIO   = 0.1

total_steps   = len(loader) * EPOCHS
warmup_steps  = int(total_steps * WARMUP_RATIO)

optimizer = AdamW(model.parameters(), lr=LEARNING_RATE, eps=1e-8)
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=warmup_steps,
    num_training_steps=total_steps
)

print(f"Total training steps: {total_steps}")
print(f"Warmup steps: {warmup_steps}")
print(f"Peak LR: {LEARNING_RATE}, then linear decay to 0")

BERT vs RoBERTa vs DistilBERT

Model            Params  Speed   Accuracy  Notes
-----------      ------  -----   --------  -----
bert-base        110M    1x      baseline  Original, safe choice
bert-large       340M    0.4x    +2-3%     Slower, better accuracy
roberta-base     125M    1x      +1-2%     Better pretraining, no NSP
distilbert-base   66M    1.6x    -3%       Great for production
albert-base        12M   0.9x    ~same     Much fewer params via sharing

For most projects: start with distilbert-base-uncased for speed, switch to roberta-base for accuracy.

Quick Cheat Sheet

Task	Model	Code
Text classification	BertForSequenceClassification	`pipeline('sentiment-analysis')`
NER	BertForTokenClassification	`pipeline('ner')`
QA	BertForQuestionAnswering	`pipeline('question-answering')`
Zero-shot	NLI model	`pipeline('zero-shot-classification')`
Custom	BertModel + linear head	`outputs.pooler_output`

Setting	Value
Learning rate	2e-5 to 5e-5
Batch size	16 or 32
Epochs	2 to 4
Max sequence length	128 to 512
Warmup steps	10% of total steps

Practice Challenges

Level 1:
Use pipeline('sentiment-analysis') on 20 movie reviews you write yourself (10 positive, 10 negative). Print each prediction and confidence score. Where does it get confused?

Level 2:
Fine-tune distilbert-base-uncased on any small classification dataset (you can use load_dataset('imdb') from HuggingFace). Train for 3 epochs. Compare accuracy to a TF-IDF + LogisticRegression baseline from Post 62. How much better is BERT?

Level 3:
Use BertForTokenClassification to tag a paragraph of news text with NER labels. Then visualize the output by color-coding each entity type in the text. Use the fine-tuned dslim/bert-base-NER model from HuggingFace hub.

References

Next up, Post 93: GPT: The Model That Predicts the Next Word Forever. Autoregressive generation, temperature and sampling strategies, and how a simple next-token prediction objective produces models that can write, code, and reason.

The AI That Manages Its Own Memory: Why Recursive Language Models Are the Next Big Shift in AI

Akhilesh — Wed, 20 May 2026 12:27:14 +0000

What I learned reading one of the most important AI papers of 2025, and why every team building with AI agents needs to understand this.

I have been following AI research seriously for a while now. I read a lot of papers, follow a lot of labs, and try to separate genuine progress from hype. Most research is incremental. Every once in a while something comes along that reframes how I think about a fundamental problem.

The Recursive Language Model is one of those things.

It does not come with a product launch or a benchmark leaderboard. It comes from a research team at Prime Intellect who looked at the core limitation of every AI agent in production today and found a cleaner answer to it. I want to share what I learned, why I think it matters, and why I believe the teams that understand this now will be ahead of the ones who discover it later.

The Real Reason AI Agents Break Down

If you have ever deployed an AI agent for a real task, not a demo, but actual production work, you have probably noticed a pattern. The first few steps look great. The agent reads, searches, reasons, takes action. Then somewhere around step twenty or thirty, things start to go wrong. Answers get less precise. Context from earlier steps seems to get lost. The model starts repeating itself or losing track of what it was trying to do.

This is not a bug in any particular model. It is a structural problem baked into how language models work.

Every tool call an agent makes returns output into its context window. Every webpage it opens, every file it reads, every search result it processes fills that window further. A single webpage opened without truncation can add more than a million tokens to the context. After enough steps, the model is not reasoning from a clean working memory. It is reasoning from an enormous pile of accumulated text, most of which is no longer relevant to the current step.

Researchers have a name for what happens next: context rot. The model's effective reasoning quality degrades as the context grows. It is not that the model becomes unintelligent. It is that the signal it needs is buried under so much noise that useful reasoning becomes increasingly difficult.

The industry has two standard responses to this problem. The first is to build bigger context windows. The second is to periodically compress the history through summarization. Both responses have genuine costs that are worth being honest about.

Bigger context windows mean higher costs. Every token in the context must be processed on every generation step, so cost rises linearly with context length. More importantly, even the best models show degraded performance on very long contexts regardless of whether the window is technically large enough to hold the content.

Summarization is the more popular approach, and on the surface it seems sensible. Keep a rolling summary of what has happened so far and use that instead of the full history. The problem is information loss. Every time you compress, you lose detail. Some of that detail seemed unimportant at the time and turns out to be critical later. Over a long task with many compression steps, those losses accumulate and you end up with an agent that is working from an increasingly distorted picture of what it actually did.

Neither of these approaches solves the problem. They manage it, at a cost.

What a Recursive Language Model Actually Is

The core idea behind the RLM is worth understanding carefully because it is both simple and genuinely different from what came before.

Instead of having the model ingest all of its input data directly into its context window, the RLM gives the model access to a persistent Python environment. Large inputs, documents, datasets, web content, API responses, all of it lives inside that Python environment rather than in the model's context. The model cannot see that data by default. It can only access data by writing Python code to retrieve, filter, search through, or transform it.

This means the model's context window stays small and clean by design. It contains the current task, the current reasoning, and whatever the model has explicitly chosen to pull in. Nothing accumulates passively.

The second key mechanic is sub-LLM delegation. From within the Python environment, the main model can instantiate fresh sub-LLMs and give them work to do. It can pass a chunk of a large document to a sub-LLM and ask it to extract specific information. It can pass a web page to a sub-LLM and ask it to answer a specific question about the content. The sub-LLM does the reading. The sub-LLM does the processing. What comes back to the main model is a tight, focused answer.

These sub-LLM calls can be parallelized. On a research task that requires investigating ten different threads, the main model can dispatch all ten sub-LLMs simultaneously and synthesize their results at once rather than working through them sequentially.

The third mechanic is the answer variable. Rather than generating a final response in a single pass, the RLM writes its answer into a Python variable. It can write an initial attempt, print it out to inspect it, compare it against the source material, identify errors, and correct them using string operations. The answer is produced through iteration rather than committed in a single generation. This matters especially for tasks that require precision, like copying complex structured data, where a single-pass generation almost always contains small errors that an iterative process can catch and fix.

What you get when these three things work together is a model that keeps its own working memory compact, offloads intensive reading and processing to disposable sub-models, and refines its outputs through inspection and correction rather than hoping the first attempt is right.

Why This Is Not Just Another Context Trick

I want to be specific about why the RLM is different from every other approach to context management, because that distinction is what makes it genuinely interesting.

Every other method involves some form of forgetting. A sliding window drops the oldest content. Summarization replaces detailed content with a compressed version. Even the most sophisticated compression techniques are lossy transformations. Once information is compressed or dropped, it cannot be recovered.

The RLM never forgets anything. The raw data is always present in the Python environment. The model can retrieve any piece of it at any point in the task with a line of code. What changes is not whether the information exists but whether it is currently loaded into the main model's attention. This is a completely different relationship with information than any summarization or compression approach can offer.

There is also a compounding benefit to this design. Because the main model's context stays small, every token in that context is relatively more important. The model is not diluting its attention across a vast accumulated history. It is reasoning from a lean, curated working memory that it has actively constructed. The quality of reasoning at step fifty of a task should look much more like the quality of reasoning at step five, because the context at step fifty has been actively managed to stay relevant.

The aspect of the RLM that I think is most underappreciated is that it is trainable end to end. The scaffolding itself can be the subject of reinforcement learning. A model can be trained directly on the RLM framework with rewards tied to how well it completes long-horizon tasks. Through that training, the model learns when it is better to delegate a piece of work to a sub-LLM versus handling it directly, how much context to pass to a sub-LLM to get a useful answer, how to phrase questions to sub-LLMs so the responses are actually helpful, and when an iterative answer is good enough to finalize.

These are not skills that can be specified through hand-written rules or prompt engineering. They require learned judgment developed through practice on real tasks. The RLM framework makes that training possible in a way that previous approaches do not.

What the Research Shows

Prime Intellect ran the RLM against four different test environments, comparing it against a standard LLM with access to the same tools. I want to describe what they found in plain terms rather than presenting it as a ranking, because the nuances matter.

On deep research tasks, the kind that involve searching the web, following multiple links, and synthesizing information from many sources, the RLM consistently outperforms the standard model. On complex queries, some open-source models showed performance close to double what they achieved without the RLM scaffold. The token analysis makes clear why. When the RLM uses sub-LLMs to do the web reading, the main model's context stays compact. The standard model accumulates all that web content directly and its reasoning degrades under the weight of it.

On long-context understanding tasks, the gap is even more stark. When inputs reach one million characters or more, the standard LLM simply fails. The API rejects the inputs as exceeding the context window. The RLM maintains meaningful performance at inputs up to around 1.75 million characters because it never tries to load the full input at once. It accesses the data in chunks through the Python environment and uses sub-LLMs to process those chunks as needed.

On tasks that require producing precise outputs, like verbatim copying of complex structured data, the RLM is consistently better. The iterative answer mechanism is the reason. The model can write a first attempt, identify where it made errors, and correct those specific errors rather than committing to a single generation. For tasks like reproducing JSON or alphanumeric codes, where small errors are easy to make and easy to fix once spotted, this is a significant advantage.

The researchers are honest about where the RLM does not help. On straightforward mathematical reasoning tasks, the standard model performs better. The explanation is that models have been heavily trained on a specific format for math tool use, and the RLM's scaffolding creates overhead without offering a compensating benefit on tasks of that type. This is a training data mismatch, not a fundamental limitation, and it is exactly the kind of gap that closes once models are trained natively on the RLM scaffold.

It is worth emphasising something about these results. They were produced with existing models called through standard APIs with absolutely no fine-tuning for the RLM interface. These are floor numbers. They represent what happens before any lab has done the obvious work of training a model to be a good RLM user. The research team is explicit that they expect training to unlock substantially larger gains.

What Changes When Models Are Trained for This

The results from off-the-shelf models are already compelling in places. But the more interesting question is what happens when a model is trained end to end to operate within the RLM framework.

A model that has been trained through reinforcement learning on the RLM scaffold learns genuine strategic judgment about context management. It learns to be selective about what it pulls into its own context versus what it delegates. It learns to construct sub-LLM queries that return genuinely useful summaries rather than verbose outputs. It learns to manage the iterative answer process efficiently, knowing when a first draft is close enough to refine and when it needs to be started over.

Those learned skills translate directly into the ability to handle the tasks that currently require teams of humans working over extended periods. A thorough audit of a large codebase is not bottlenecked by intelligence. It is bottlenecked by the ability to maintain coherent reasoning across hundreds of files and thousands of observations made over many hours. An RLM trained to manage its context well can do that in a way that no current system can.

The same applies to long-horizon research, multi-step legal analysis, large-scale data extraction, and any workflow where sustained coherent operation across many steps is the bottleneck rather than raw capability on any individual step.

Why the Architecture of the RLM Is Itself an Advantage

One thing I keep coming back to is how the RLM is structured from the outside.

To any system that calls it, an RLM looks identical to a standard LLM. It accepts text input and returns text output. There is no new API format to learn, no restructuring of the calling system required, no changes to how the task is framed. A company that currently uses a standard LLM through an API can adopt RLM capabilities without rewriting anything on their end.

This matters for adoption. The history of technology is full of genuinely better solutions that failed because the switching cost was too high. The RLM has essentially no switching cost. The entire complexity of context management is internal to the model. From the outside it is invisible.

What I Think This Means

I want to be honest about where I stand on this.

The gap in AI today is not about intelligence on individual tasks. Models are already capable enough to handle most of what knowledge workers do on any given task when that task is contained. The gap is about sustained operation. The ability to work for hours or days across a large, evolving body of information without losing coherence. The ability to maintain the thread of a complex project from step one to step one hundred without the context of the early steps becoming inaccessible.

The RLM is the clearest solution to that gap that I have seen. It does not paper over the problem with a bigger window or a lossier compression. It redesigns the relationship between the model and its information so that the problem does not arise in the same way.

The research is published. The framework is open. The teams that take it seriously now, before purpose-trained models exist and before this becomes obvious to everyone, are the ones who will be positioned well when those models arrive.

Read the Full Research

Everything I have described here is covered in much greater technical depth in the original paper. If you work in AI engineering, agent systems, or anywhere that long-horizon tasks matter, I think it is genuinely worth reading in full.

Full paper: https://arxiv.org/html/2512.24601v3

If you found this useful, share it with someone who is building on AI agents. The more openly this conversation happens, the better the tools we all end up with.

90. Phase 8 Capstone: Build a Full AI Application

Akhilesh — Wed, 20 May 2026 00:57:31 +0000

Phase 8 has been building to this.

Tokenization. Embeddings. Transformers. BERT. GPT. HuggingFace. Fine-tuning. Vector search. RAG. Chatbot architecture. OpenAI API. Claude API.

Fourteen posts of foundations.

Now you ship something real.

This capstone builds DocuMind: an AI research assistant that lets users upload any PDF or text document and have intelligent conversations about it. It retrieves relevant passages, cites sources, maintains conversation context, and deploys as a shareable web application.

It is not the most complex system ever built. It is exactly complex enough to require every concept from Phase 8, and simple enough to build completely in one post.

What You Are Building

DocuMind: AI Research Assistant

Features:
  ✓ Upload PDFs and text files
  ✓ Automatic chunking and embedding
  ✓ Semantic search over uploaded documents
  ✓ Multi-turn conversation with memory
  ✓ Source citations on every answer
  ✓ Multi-document support
  ✓ Deployable Streamlit app

Tech stack:
  - sentence-transformers  (embeddings)
  - chromadb               (vector store)
  - anthropic / openai     (LLM)
  - streamlit              (UI)
  - pypdf                  (PDF parsing)
  - langchain text splitter (chunking)

Project Structure

documind/
├── app.py                  # Streamlit application entry point
├── config.py               # Configuration and constants
├── document_processor.py   # PDF/text loading, chunking, embedding
├── knowledge_base.py       # ChromaDB vector store wrapper
├── conversation.py         # Multi-turn conversation management
├── llm_client.py           # Pluggable LLM backend (Claude or OpenAI)
├── rag_engine.py           # Retrieval-augmented generation pipeline
├── requirements.txt        # All dependencies
└── README.md               # Setup and usage instructions

config.py

# config.py
from dataclasses import dataclass

@dataclass
class Config:
    # Embedding model
    EMBED_MODEL:      str   = "all-MiniLM-L6-v2"
    EMBED_DIM:        int   = 384

    # Chunking
    CHUNK_SIZE:       int   = 512
    CHUNK_OVERLAP:    int   = 64

    # Retrieval
    TOP_K_RETRIEVE:   int   = 5
    TOP_K_RERANK:     int   = 3
    MIN_SCORE:        float = 0.25

    # Conversation
    MAX_HISTORY_TURNS: int  = 8

    # LLM
    LLM_PROVIDER:     str   = "anthropic"     # "anthropic" or "openai"
    ANTHROPIC_MODEL:  str   = "claude-3-5-haiku-20241022"
    OPENAI_MODEL:     str   = "gpt-4o-mini"
    MAX_TOKENS:       int   = 800
    TEMPERATURE:      float = 0.2

    # ChromaDB
    CHROMA_PATH:      str   = "./chroma_db"
    COLLECTION_NAME:  str   = "documind"

CONFIG = Config()

document_processor.py

# document_processor.py
import re
from pathlib import Path
from typing import List, Dict
from dataclasses import dataclass

@dataclass
class Chunk:
    text:       str
    source:     str
    page:       int
    chunk_idx:  int
    char_start: int

def load_text_file(filepath: str) -> str:
    with open(filepath, "r", encoding="utf-8", errors="replace") as f:
        return f.read()

def load_pdf(filepath: str) -> List[Dict]:
    """Return list of {text, page} dicts."""
    try:
        import pypdf
        pages = []
        with open(filepath, "rb") as f:
            reader = pypdf.PdfReader(f)
            for i, page in enumerate(reader.pages):
                text = page.extract_text() or ""
                if text.strip():
                    pages.append({"text": text, "page": i + 1})
        return pages
    except ImportError:
        raise ImportError("Install: pip install pypdf")

def clean_text(text: str) -> str:
    text = re.sub(r"\s+", " ", text)
    text = re.sub(r"(\n\s*){3,}", "\n\n", text)
    return text.strip()

def chunk_text(text: str, source: str, page: int = 1,
               chunk_size: int = 512, overlap: int = 64) -> List[Chunk]:
    """Recursive character splitting with overlap."""
    text    = clean_text(text)
    words   = text.split()
    chunks  = []
    idx     = 0
    step    = chunk_size - overlap

    while idx < len(words):
        chunk_words = words[idx:idx + chunk_size]
        chunk_text  = " ".join(chunk_words)

        if len(chunk_text.strip()) > 50:
            chunks.append(Chunk(
                text      = chunk_text,
                source    = source,
                page      = page,
                chunk_idx = len(chunks),
                char_start= idx
            ))
        idx += step

    return chunks

def process_document(filepath: str,
                     chunk_size: int = 512,
                     overlap: int    = 64) -> List[Chunk]:
    """Load and chunk any supported document type."""
    path = Path(filepath)
    all_chunks = []

    if path.suffix.lower() == ".pdf":
        pages = load_pdf(filepath)
        for page_data in pages:
            chunks = chunk_text(
                page_data["text"],
                source     = path.name,
                page       = page_data["page"],
                chunk_size = chunk_size,
                overlap    = overlap
            )
            all_chunks.extend(chunks)

    elif path.suffix.lower() in [".txt", ".md", ".rst"]:
        text   = load_text_file(filepath)
        chunks = chunk_text(
            text,
            source     = path.name,
            page       = 1,
            chunk_size = chunk_size,
            overlap    = overlap
        )
        all_chunks.extend(chunks)

    else:
        raise ValueError(f"Unsupported file type: {path.suffix}")

    print(f"  Processed {path.name}: {len(all_chunks)} chunks")
    return all_chunks

knowledge_base.py

# knowledge_base.py
import uuid
from typing import List, Dict, Optional
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.config import Settings
from document_processor import Chunk

class KnowledgeBase:
    def __init__(self, embed_model: str, persist_dir: str, collection_name: str):
        self.embedder   = SentenceTransformer(embed_model)
        self.client     = chromadb.PersistentClient(path=persist_dir)
        self.collection = self.client.get_or_create_collection(
            name     = collection_name,
            metadata = {"hnsw:space": "cosine"}
        )
        self._source_cache = {}

    def add_chunks(self, chunks: List[Chunk]) -> int:
        if not chunks:
            return 0

        texts      = [c.text for c in chunks]
        embeddings = self.embedder.encode(texts, show_progress_bar=True).tolist()

        ids        = [str(uuid.uuid4()) for _ in chunks]
        metadatas  = [
            {"source":    c.source,
             "page":      c.page,
             "chunk_idx": c.chunk_idx}
            for c in chunks
        ]

        self.collection.add(
            ids        = ids,
            embeddings = embeddings,
            documents  = texts,
            metadatas  = metadatas
        )

        for chunk in chunks:
            self._source_cache[chunk.source] = True

        return len(chunks)

    def retrieve(self, query: str, top_k: int = 5,
                 min_score: float = 0.25,
                 filter_source: Optional[str] = None) -> List[Dict]:
        query_emb  = self.embedder.encode([query]).tolist()
        where      = {"source": filter_source} if filter_source else None

        results = self.collection.query(
            query_embeddings = query_emb,
            n_results        = top_k,
            where            = where,
            include          = ["documents", "metadatas", "distances"]
        )

        retrieved = []
        for text, meta, dist in zip(
            results["documents"][0],
            results["metadatas"][0],
            results["distances"][0]
        ):
            score = 1 - dist
            if score >= min_score:
                retrieved.append({
                    "text":   text,
                    "source": meta["source"],
                    "page":   meta["page"],
                    "score":  round(score, 4)
                })

        return retrieved

    def get_sources(self) -> List[str]:
        return list(self._source_cache.keys())

    def document_count(self) -> int:
        return self.collection.count()

    def clear(self):
        self.client.delete_collection(self.collection.name)
        self.collection = self.client.get_or_create_collection(
            name=self.collection.name,
            metadata={"hnsw:space": "cosine"}
        )
        self._source_cache = {}

llm_client.py

# llm_client.py
import os
from abc import ABC, abstractmethod
from typing import List, Dict

class LLMClient(ABC):
    @abstractmethod
    def complete(self, system: str, messages: List[Dict],
                 max_tokens: int = 800, temperature: float = 0.2) -> str:
        pass

class ClaudeClient(LLMClient):
    def __init__(self, model: str = "claude-3-5-haiku-20241022"):
        import anthropic
        self.client = anthropic.Anthropic(
            api_key=os.environ.get("ANTHROPIC_API_KEY"))
        self.model  = model

    def complete(self, system, messages, max_tokens=800, temperature=0.2):
        response = self.client.messages.create(
            model=self.model, max_tokens=max_tokens,
            temperature=temperature, system=system, messages=messages
        )
        return response.content[0].text

class OpenAIClient(LLMClient):
    def __init__(self, model: str = "gpt-4o-mini"):
        import openai
        self.client = openai.OpenAI(
            api_key=os.environ.get("OPENAI_API_KEY"))
        self.model  = model

    def complete(self, system, messages, max_tokens=800, temperature=0.2):
        all_msgs = [{"role": "system", "content": system}] + messages
        response = self.client.chat.completions.create(
            model=self.model, messages=all_msgs,
            max_tokens=max_tokens, temperature=temperature
        )
        return response.choices[0].message.content

def get_llm_client(provider: str = "anthropic", **kwargs) -> LLMClient:
    if provider == "anthropic":
        return ClaudeClient(**kwargs)
    elif provider == "openai":
        return OpenAIClient(**kwargs)
    raise ValueError(f"Unknown provider: {provider}")

rag_engine.py

# rag_engine.py
from typing import List, Dict, Tuple
from knowledge_base import KnowledgeBase
from llm_client import LLMClient

SYSTEM_PROMPT = """You are DocuMind, an AI research assistant.
Your job is to answer questions based ONLY on the provided document context.

Rules:
- Use only information from the provided context
- Cite sources using [1], [2] etc. at the end of relevant sentences
- If the answer is not in the context, say exactly: "I couldn't find information about this in the uploaded documents."
- Be precise and concise
- If multiple documents are relevant, synthesize them coherently
- Format responses with markdown when helpful"""

def build_context_block(retrieved: List[Dict]) -> str:
    parts = []
    for i, doc in enumerate(retrieved, 1):
        parts.append(
            f"[{i}] Source: {doc['source']} (page {doc['page']}, "
            f"relevance: {doc['score']:.0%})\n{doc['text']}"
        )
    return "\n\n".join(parts)

def build_rag_message(user_question: str,
                       retrieved: List[Dict]) -> str:
    context = build_context_block(retrieved)
    return (
        f"Context from documents:\n\n{context}\n\n"
        f"Question: {user_question}"
    )

class RAGEngine:
    def __init__(self, kb: KnowledgeBase, llm: LLMClient,
                 top_k: int = 5, min_score: float = 0.25):
        self.kb        = kb
        self.llm       = llm
        self.top_k     = top_k
        self.min_score = min_score

    def answer(self, question: str,
               history: List[Dict] = None) -> Tuple[str, List[Dict]]:
        """
        Returns (answer_text, retrieved_docs)
        history: previous conversation messages in API format
        """
        retrieved = self.kb.retrieve(
            question, top_k=self.top_k, min_score=self.min_score)

        messages = list(history or [])

        if retrieved:
            rag_content = build_rag_message(question, retrieved)
            messages.append({"role": "user", "content": rag_content})
        else:
            messages.append({"role": "user", "content": question})

        answer = self.llm.complete(
            system    = SYSTEM_PROMPT,
            messages  = messages,
            max_tokens= 800,
            temperature= 0.2
        )

        return answer, retrieved

conversation.py

# conversation.py
from dataclasses import dataclass, field
from typing import List, Dict
import time

@dataclass
class Turn:
    question:  str
    answer:    str
    sources:   List[str]
    timestamp: float = field(default_factory=time.time)

class Conversation:
    def __init__(self, max_turns: int = 8):
        self.turns:     List[Turn] = []
        self.max_turns: int        = max_turns

    def add(self, question: str, answer: str, sources: List[str]):
        self.turns.append(Turn(question, answer, sources))

    def get_api_history(self) -> List[Dict]:
        """Return last max_turns as API message format."""
        recent = self.turns[-self.max_turns:]
        messages = []
        for turn in recent:
            messages.append({"role": "user",      "content": turn.question})
            messages.append({"role": "assistant",  "content": turn.answer})
        return messages

    def clear(self):
        self.turns = []

    def __len__(self):
        return len(self.turns)

app.py — The Streamlit Interface

# app.py
import streamlit as st
import tempfile
import os
from pathlib import Path

from config import CONFIG
from document_processor import process_document
from knowledge_base import KnowledgeBase
from llm_client import get_llm_client
from rag_engine import RAGEngine
from conversation import Conversation

st.set_page_config(
    page_title = "DocuMind — AI Research Assistant",
    page_icon  = "📚",
    layout     = "wide"
)

@st.cache_resource
def init_system():
    kb  = KnowledgeBase(
        embed_model     = CONFIG.EMBED_MODEL,
        persist_dir     = CONFIG.CHROMA_PATH,
        collection_name = CONFIG.COLLECTION_NAME
    )
    llm = get_llm_client(
        provider = CONFIG.LLM_PROVIDER,
        model    = (CONFIG.ANTHROPIC_MODEL
                    if CONFIG.LLM_PROVIDER == "anthropic"
                    else CONFIG.OPENAI_MODEL)
    )
    engine = RAGEngine(kb, llm, top_k=CONFIG.TOP_K_RETRIEVE)
    return kb, engine

kb, engine = init_system()

if "conversation" not in st.session_state:
    st.session_state.conversation = Conversation(CONFIG.MAX_HISTORY_TURNS)
if "messages_display" not in st.session_state:
    st.session_state.messages_display = []

with st.sidebar:
    st.title("📚 DocuMind")
    st.markdown("Upload documents to start asking questions.")
    st.divider()

    uploaded = st.file_uploader(
        "Upload documents",
        type    = ["pdf", "txt", "md"],
        accept_multiple_files = True
    )

    if uploaded:
        for f in uploaded:
            with st.spinner(f"Processing {f.name}..."):
                with tempfile.NamedTemporaryFile(
                    delete=False, suffix=Path(f.name).suffix
                ) as tmp:
                    tmp.write(f.read())
                    tmp_path = tmp.name

                try:
                    chunks = process_document(tmp_path, CONFIG.CHUNK_SIZE, CONFIG.CHUNK_OVERLAP)
                    added  = kb.add_chunks(chunks)
                    st.success(f"✓ {f.name}: {added} chunks indexed")
                except Exception as e:
                    st.error(f"Error: {e}")
                finally:
                    os.unlink(tmp_path)

    sources = kb.get_sources()
    if sources:
        st.divider()
        st.subheader(f"📄 Documents ({len(sources)})")
        for src in sources:
            st.markdown(f"• {src}")

    st.divider()
    col1, col2 = st.columns(2)
    with col1:
        st.metric("Chunks", kb.document_count())
    with col2:
        st.metric("Turns", len(st.session_state.conversation))

    if st.button("🗑 Clear conversation"):
        st.session_state.conversation = Conversation(CONFIG.MAX_HISTORY_TURNS)
        st.session_state.messages_display = []
        st.rerun()

st.title("DocuMind — AI Research Assistant")

if not sources:
    st.info("👈 Upload a document in the sidebar to get started.")
else:
    for msg in st.session_state.messages_display:
        with st.chat_message(msg["role"]):
            st.markdown(msg["content"])
            if msg.get("sources"):
                with st.expander("📎 Sources"):
                    for src in msg["sources"]:
                        st.markdown(
                            f"**{src['source']}** (page {src['page']}) — "
                            f"relevance {src['score']:.0%}\n\n> {src['text'][:200]}..."
                        )

    if question := st.chat_input("Ask anything about your documents..."):
        st.session_state.messages_display.append(
            {"role": "user", "content": question})
        with st.chat_message("user"):
            st.markdown(question)

        with st.chat_message("assistant"):
            with st.spinner("Searching and generating answer..."):
                history = st.session_state.conversation.get_api_history()
                answer, retrieved = engine.answer(question, history=history)

            st.markdown(answer)

            if retrieved:
                with st.expander(f"📎 {len(retrieved)} source(s) used"):
                    for i, src in enumerate(retrieved, 1):
                        st.markdown(
                            f"**[{i}] {src['source']}** — page {src['page']} "
                            f"(relevance: {src['score']:.0%})"
                        )
                        st.caption(src["text"][:300] + "...")
                        st.divider()

        st.session_state.conversation.add(
            question = question,
            answer   = answer,
            sources  = [r["source"] for r in retrieved]
        )
        st.session_state.messages_display.append({
            "role":    "assistant",
            "content": answer,
            "sources": retrieved
        })

requirements.txt

anthropic>=0.25.0
openai>=1.0.0
streamlit>=1.32.0
sentence-transformers>=2.7.0
chromadb>=0.4.24
pypdf>=4.0.0
langchain-text-splitters>=0.0.1

Deployment

# Local
streamlit run app.py

# Streamlit Community Cloud (free)
# 1. Push to GitHub
# 2. Go to share.streamlit.io
# 3. Connect repo → select app.py
# 4. Add secrets:
#    ANTHROPIC_API_KEY = "sk-ant-..."
#    or
#    OPENAI_API_KEY = "sk-..."
# 5. Deploy

# Docker (for self-hosting)
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8501
CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

Evaluation: Did It Work?

def evaluate_documind(engine, test_cases):
    """
    test_cases: [{"question": str, "expected_keyword": str, "source": str}]
    """
    results = []
    for case in test_cases:
        answer, retrieved = engine.answer(case["question"])

        keyword_found = case["expected_keyword"].lower() in answer.lower()
        source_cited  = any(case["source"] in r["source"] for r in retrieved)
        no_hallucination = "couldn't find" not in answer.lower()

        results.append({
            "question":      case["question"][:40],
            "keyword_found": keyword_found,
            "source_cited":  source_cited,
            "answered":      no_hallucination,
        })

    print("\nEvaluation Results:")
    print(f"{'Question':<42} {'Keyword':>8} {'Source':>7} {'Answered':>9}")
    print("=" * 70)
    for r in results:
        print(f"{r['question']:<42} "
              f"{'✓' if r['keyword_found'] else '✗':>8} "
              f"{'✓' if r['source_cited'] else '✗':>7} "
              f"{'✓' if r['answered'] else '✗':>9}")

    acc = sum(r["keyword_found"] and r["source_cited"] for r in results) / len(results)
    print(f"\nOverall accuracy: {acc:.0%}")

Reference Links

print("Everything you need to go further:")
print()

refs = {
    "Core Libraries": [
        ("ChromaDB docs",              "docs.trychroma.com"),
        ("Sentence Transformers",      "sbert.net/docs/quickstart.html"),
        ("Streamlit docs",             "docs.streamlit.io"),
        ("pypdf",                      "pypdf.readthedocs.io"),
        ("Anthropic Python SDK",       "github.com/anthropics/anthropic-sdk-python"),
        ("OpenAI Python SDK",          "github.com/openai/openai-python"),
    ],
    "Advanced RAG Patterns": [
        ("LlamaIndex RAG guide",       "docs.llamaindex.ai/en/stable/use_cases/q_and_a"),
        ("LangChain RAG tutorial",     "python.langchain.com/docs/use_cases/question_answering"),
        ("RAGAS evaluation framework", "docs.ragas.io"),
        ("Pinecone RAG guide",         "pinecone.io/learn/retrieval-augmented-generation"),
    ],
    "Deployment": [
        ("Streamlit Community Cloud",  "share.streamlit.io"),
        ("Render (free tier)",         "render.com"),
        ("Railway",                    "railway.app"),
        ("HuggingFace Spaces",         "huggingface.co/spaces"),
    ],
    "Making It Production-Grade": [
        ("LangSmith (LLM observability)", "smith.langchain.com"),
        ("Arize Phoenix (tracing)",    "phoenix.arize.com"),
        ("Weights & Biases (logging)", "wandb.ai/site/llm"),
        ("TruLens (RAG evaluation)",   "trulens.org"),
    ],
}

for category, links in refs.items():
    print(f"  {category}:")
    for name, url in links:
        print(f"    • {name:<40} {url}")
    print()

What Makes This Portfolio-Worthy

DocuMind demonstrates every Phase 8 concept in a working product:

Tokenization + Embeddings: chunking text then encoding with sentence-transformers. The foundation of everything.

Vector search: ChromaDB with cosine similarity. Semantic retrieval, not keyword matching.

RAG: retrieved context injected into the LLM prompt with source citations.

Conversation memory: multi-turn context maintained across the full session.

LLM API: pluggable Claude or OpenAI backend with proper error handling.

Deployment: live, shareable URL in minutes via Streamlit Community Cloud.

Add a strong README with a demo GIF and this belongs in the first 10 seconds of a portfolio review.

Phase 8 Complete

You now know how language models work from the inside out.

Tokenization → Embeddings → Attention → Transformer → BERT → GPT → HuggingFace → Fine-tuning → Vector Search → RAG → Chatbot → APIs → Deployed Application.

Phase 9 starts next: MLOps. How do you take a model and make it reliable, monitored, versioned, and scalable in production? Docker, FastAPI, CI/CD, model monitoring, A/B testing. The difference between a model that works and a product that works.

Try This

Build DocuMind completely. Not a modified version. This exact system.

Upload your university notes, a book you are reading, your company documentation, or the papers from this series. Ask it questions. Push it to GitHub. Deploy to Streamlit Cloud. Share the URL with someone.

Then extend it with one feature of your choice:

Multi-language support (detect language, respond in same language)
Document comparison mode (ask questions that compare two documents)
Export conversation as PDF
Integration with a second vector store for a persistent company knowledge base
User authentication with per-user document storage

Your choice. Make it yours.