How to Add Memory to Your AI Chatbot Without a Database

from ollama import chat  # works the same with openai library

# This list IS the memory — it grows with every turn
conversation_history = [
    {
        "role": "system",
        "content": (
            "You are a helpful assistant. Be concise and direct. "
            "Remember details the user shares about themselves."
        ),
    }
]

def chat_with_memory(user_message: str) -> str:
    # Add the user's message to history
    conversation_history.append({
        "role": "user",
        "content": user_message
    })

    # Send the full history to the model
    response = chat(
        model="llama3.2",
        messages=conversation_history,
    )

    assistant_reply = response["message"]["content"]

    # Add the model's reply to history too
    conversation_history.append({
        "role": "assistant",
        "content": assistant_reply
    })

    return assistant_reply


# Usage
print(chat_with_memory("My name is Sara and I'm learning Python."))
# → "Nice to meet you, Sara! ..."

print(chat_with_memory("What's my name?"))
# → "Your name is Sara." ✓ It remembers!

from ollama import chat

SYSTEM_PROMPT = {
    "role": "system",
    "content": "You are a helpful assistant. Be concise.",
}

# Only keep the last N *pairs* of messages (user + assistant)
MAX_PAIRS = 10  # = 20 messages total in the window

full_history: list[dict] = []

def build_window(history: list[dict], max_pairs: int) -> list[dict]:
    """Return system prompt + last max_pairs exchanges."""
    # Each exchange = 1 user message + 1 assistant message = 2 items
    cutoff = max_pairs * 2
    recent = history[-cutoff:] if len(history) > cutoff else history
    return [SYSTEM_PROMPT] + recent

def chat_with_window(user_message: str) -> str:
    full_history.append({"role": "user", "content": user_message})

    # Only send the recent window to the model
    windowed_messages = build_window(full_history, MAX_PAIRS)

    response = chat(model="llama3.2", messages=windowed_messages)
    reply = response["message"]["content"]

    full_history.append({"role": "assistant", "content": reply})
    return reply

from ollama import chat

WINDOW_SIZE = 6   # messages before we summarize
summary: str = "" # grows over time as history compresses
recent_history: list[dict] = []

def summarize_history(messages: list[dict]) -> str:
    """Ask the model to compress a list of messages into a summary."""
    transcript = "\n".join(
        f"{m['role'].upper()}: {m['content']}" for m in messages
    )
    response = chat(
        model="llama3.2",
        messages=[
            {
                "role": "user",
                "content": (
                    f"Summarize this conversation excerpt in 3-5 sentences. "
                    f"Focus on key facts, user preferences, and decisions made.\n\n"
                    f"{transcript}"
                ),
            }
        ],
    )
    return response["message"]["content"]

def build_messages_with_summary(user_message: str) -> list[dict]:
    system_content = "You are a helpful assistant. Be concise."
    if summary:
        system_content += (
            f"\n\nContext from earlier in this conversation:\n{summary}"
        )
    return [
        {"role": "system", "content": system_content},
        *recent_history,
        {"role": "user", "content": user_message},
    ]

def chat_with_summary_memory(user_message: str) -> str:
    global summary, recent_history

    messages = build_messages_with_summary(user_message)
    response = chat(model="llama3.2", messages=messages)
    reply = response["message"]["content"]

    # Add this exchange to recent history
    recent_history.append({"role": "user", "content": user_message})
    recent_history.append({"role": "assistant", "content": reply})

    # When the window fills up, compress the oldest half into the summary
    if len(recent_history) >= WINDOW_SIZE:
        to_summarize = recent_history[: WINDOW_SIZE // 2]
        new_summary_chunk = summarize_history(to_summarize)

        # Append the new chunk to the existing summary
        if summary:
            summary = f"{summary}\n{new_summary_chunk}"
        else:
            summary = new_summary_chunk

        # Keep only the newer half of recent history
        recent_history = recent_history[WINDOW_SIZE // 2 :]

    return reply

import json
from ollama import chat

user_facts: dict = {}  # {"name": "Sara", "skill_level": "beginner", ...}

def extract_facts(user_message: str, assistant_reply: str) -> dict:
    """Ask the model to pull any new facts from this exchange."""
    prompt = f"""
Extract any personal facts about the user from this exchange.
Return ONLY a JSON object (or empty {{}} if nothing new).

User: {user_message}
Assistant: {assistant_reply}

Examples of facts to extract: name, location, job, skill level,
preferences, goals, constraints, tools they use.
"""
    response = chat(
        model="llama3.2",
        messages=[{"role": "user", "content": prompt}],
    )
    try:
        text = response["message"]["content"]
        # Strip markdown fences if the model adds them
        text = text.strip().strip("'''json").strip("'''").strip()
              return json.loads(text)
              except (json.JSONDecodeError, KeyError):
              return { }

              def build_system_prompt() -> str:
              base = "You are a helpful assistant. Be concise."
              if user_facts:
              facts_text = "\n".join(f"- {k}: {v}" for k, v in user_facts.items())
              base += f"\n\nWhat you know about this user:\n{facts_text}"
              return base

def chat_with_facts(user_message: str) -> str:
              messages = [
              {"role": "system", "content": build_system_prompt()},
              {"role": "user", "content": user_message},
              ]
              response = chat(model="llama3.2", messages=messages)
              reply = response["message"]["content"]

              # Async-friendly: extract facts after responding
              new_facts = extract_facts(user_message, reply)
              user_facts.update(new_facts)

              return reply

              # Example session
              print(chat_with_facts("I'm Alex, a backend dev who hates verbose docs."))
              print(user_facts)
              # → {"name": "Alex", "job": "backend developer", "preference": "concise docs"}

              print(chat_with_facts("What's a good tool for API testing?"))
# The model now knows Alex is a backend dev and will tailor its answer