Μνήμη AI Agents με Python: Πώς να Χτίσεις Πράκτορες που Θυμούνται

Γιατί τα LLMs Ξεχνάνε — και Γιατί Αυτό Είναι Πρόβλημα

Αν έχεις δουλέψει έστω και λίγο με AI agents, ξέρεις ήδη τον παραλογισμό: ένας πράκτορας μπορεί να γράψει κώδικα, να αναλύσει δεδομένα, ακόμα και να πάρει σύνθετες αποφάσεις — αλλά τη στιγμή που κλείσεις τη συνομιλία, τα ξεχνάει όλα. Κυριολεκτικά όλα. Δεν θυμάται ότι προτιμάς TypeScript, ότι η βάση σου τρέχει σε PostgreSQL, ή ότι σου είχε λύσει ένα bug πριν δύο εβδομάδες.

Κάθε νέα συνεδρία ξεκινάει σαν να μην υπήρξε ποτέ η προηγούμενη.

Κι αυτό δεν είναι αδυναμία — είναι σχεδιαστική επιλογή. Τα LLMs είναι εξ ορισμού stateless: κάθε κλήση API λαμβάνει ένα context window, παράγει μια απάντηση, και τελειώνει. Κανένα εσωτερικό state δεν μεταφέρεται μεταξύ κλήσεων. Τελεία και παύλα.

Το 2026 όμως, αυτό δεν είναι πια αποδεκτό. Πάνω από το 78% των production AI agents χρειάζονται κάποια μορφή μακροπρόθεσμης μνήμης. Οι χρήστες περιμένουν εξατομικευμένες απαντήσεις — και τα frameworks που λύνουν αυτό το πρόβλημα (Mem0, Letta, LangMem) βρίσκονται σε εκρηκτική ανάπτυξη.

Λοιπόν, σε αυτόν τον οδηγό θα δούμε ακριβώς πώς δουλεύει η μνήμη στους AI agents, ποιοι είναι οι βασικοί τύποι, και θα γράψουμε πραγματικό κώδικα σε Python με τα πιο δημοφιλή εργαλεία. Πάμε.

Αρχιτεκτονική Μνήμης: Τα 4 Επίπεδα

Η μνήμη στους AI agents δεν είναι ενιαία — χωρίζεται σε επίπεδα που, ειλικρινά, μοιάζουν εκπληκτικά με τον τρόπο που δουλεύει ο ανθρώπινος εγκέφαλος. Σκέψου το σαν μια ιεραρχία: από τα πρόσφατα (και εύκολα προσβάσιμα) δεδομένα, μέχρι τα βαθύτερα στρώματα γνώσης.

1. Βραχυπρόθεσμη Μνήμη (Short-Term Memory)

Αυτό πιθανότατα το ξέρεις ήδη, ακόμα κι αν δεν το ονομάζεις έτσι: είναι απλά το ιστορικό συνομιλίας μέσα στο context window. Κάθε φορά που στέλνεις ένα μήνυμα, όλα τα προηγούμενα μηνύματα μπαίνουν στο prompt.

Απλό, αλλά με σοβαρό περιορισμό — ακόμα και τα μοντέλα με 200K tokens context window δεν χωράνε εβδομάδες συνομιλιών.

2. Μνήμη Εργασίας (Working Memory)

Η μνήμη εργασίας δεν αποθηκεύει τι ειπώθηκε, αλλά τι σκέφτεται ο agent αυτή τη στιγμή. Είναι σαν ένα δομημένο σημειωματάριο: κρατάει ενδιάμεσα αποτελέσματα, τρέχουσα κατάσταση σχεδίου, μεταβλητές ελέγχου ροής. Στην πράξη, ένα JSON scratchpad που το LLM διαβάζει και γράφει σε κάθε βήμα είναι πολύ πιο αξιόπιστο από το να ζητάς από το μοντέλο να «θυμάται» ελεύθερο κείμενο (πίστεψέ με, δεν δουλεύει καλά).

3. Μακροπρόθεσμη Μνήμη (Long-Term Memory)

Εδώ βρίσκεται η πραγματική καινοτομία. Η μακροπρόθεσμη μνήμη επιβιώνει μεταξύ sessions, αποθηκεύεται σε εξωτερικές βάσεις δεδομένων (vector stores, knowledge graphs) και ανακτάται μέσω σημασιολογικής αναζήτησης. Η τυπική αρχιτεκτονική μοιάζει κάπως έτσι:

• Εξαγωγή γεγονότων — Το LLM αναλύει τη συνομιλία και εξάγει discrete facts
• Embedding — Κάθε fact μετατρέπεται σε vector
• Αποθήκευση — Τα vectors πάνε σε vector database (Qdrant, ChromaDB, Pinecone)
• Ανάκτηση — Σε κάθε νέα ερώτηση, similarity search φέρνει τις σχετικές μνήμες

4. Επεισοδιακή Μνήμη (Episodic Memory)

Σε αντίθεση με τη σημασιολογική μνήμη που αποθηκεύει γεγονότα (π.χ. «ο χρήστης χρησιμοποιεί PostgreSQL»), η επεισοδιακή μνήμη αποθηκεύει ολόκληρο το πλαίσιο μιας αλληλεπίδρασης. Δηλαδή, την κατάσταση, τη διαδικασία σκέψης, και γιατί μια συγκεκριμένη προσέγγιση λειτούργησε. Αυτό βοηθάει τον agent να μαθαίνει από εμπειρία — όχι μόνο από δεδομένα.

Ρύθμιση Περιβάλλοντος

Πριν πιάσουμε κώδικα, ας στήσουμε ένα κοινό περιβάλλον. Χρειαζόμαστε Python 3.10+ και τα SDK τριών frameworks:

python -m venv memory-env
source memory-env/bin/activate

# Core dependencies
pip install openai anthropic python-dotenv

# Memory frameworks
pip install mem0ai letta-client langmem

Δημιούργησε ένα αρχείο .env:

OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
LETTA_API_KEY=...

Μέθοδος 1: Χειροκίνητη Μνήμη με Pure Python

Πριν πηδήξουμε σε frameworks, αξίζει να καταλάβεις πώς δουλεύει η μνήμη «χειροκίνητα». Είναι ο καλύτερος τρόπος να καταλάβεις τι κάνουν τα frameworks κάτω από το καπό — κι ειλικρινά, για μικρά projects μπορεί να μη χρειαστείς τίποτα παραπάνω.

import json
import sqlite3
from datetime import datetime
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

class SimpleMemoryStore:
    """Minimal memory store using SQLite."""

    def __init__(self, db_path: str = "agent_memory.db"):
        self.conn = sqlite3.connect(db_path)
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                user_id TEXT NOT NULL,
                fact TEXT NOT NULL,
                category TEXT DEFAULT 'general',
                created_at TEXT NOT NULL,
                relevance_score REAL DEFAULT 1.0
            )
        """)
        self.conn.commit()

    def add_memory(self, user_id: str, fact: str, category: str = "general"):
        self.conn.execute(
            "INSERT INTO memories (user_id, fact, category, created_at) VALUES (?, ?, ?, ?)",
            (user_id, fact, category, datetime.utcnow().isoformat())
        )
        self.conn.commit()

    def search_memories(self, user_id: str, limit: int = 5) -> list[str]:
        cursor = self.conn.execute(
            "SELECT fact FROM memories WHERE user_id = ? ORDER BY created_at DESC LIMIT ?",
            (user_id, limit)
        )
        return [row[0] for row in cursor.fetchall()]

def extract_facts(conversation: list[dict]) -> list[str]:
    """Use the LLM to extract memorable facts from a conversation."""
    extraction_prompt = """Analyze this conversation and extract important facts 
about the user (preferences, technical stack, past issues, personal info).
Return a JSON array of strings, one fact per element.
Only include facts worth remembering long-term."""

    response = client.chat.completions.create(
        model="gpt-4.1-nano",
        messages=[
            {"role": "system", "content": extraction_prompt},
            {"role": "user", "content": json.dumps(conversation)}
        ],
        response_format={"type": "json_object"}
    )
    result = json.loads(response.choices[0].message.content)
    return result.get("facts", [])

# Usage
store = SimpleMemoryStore()

conversation = [
    {"role": "user", "content": "Δουλεύω με FastAPI και PostgreSQL"},
    {"role": "assistant", "content": "Τέλεια! Πώς μπορώ να βοηθήσω;"},
    {"role": "user", "content": "Θέλω να φτιάξω ένα RAG pipeline σε Python 3.12"}
]

# Extract and store facts
facts = extract_facts(conversation)
for fact in facts:
    store.add_memory("user_123", fact)

# Later: retrieve memories for a new conversation
memories = store.search_memories("user_123")
print("Stored memories:", memories)

Δουλεύει μια χαρά αυτή η προσέγγιση. Αλλά έχει ένα σημαντικό μειονέκτημα: η αναζήτηση βασίζεται μόνο σε χρονολογία, όχι σε σημασιολογική ομοιότητα. Αν ψάχνεις τι framework χρησιμοποιεί ο χρήστης, δεν αρκεί να πάρεις τις 5 πιο πρόσφατες μνήμες — χρειάζεσαι αυτές που μοιάζουν σημασιολογικά με την ερώτηση. Γι' αυτό χρειάζονται vector embeddings, κάτι που τα παρακάτω frameworks κάνουν αυτόματα.

Μέθοδος 2: Mem0 — Αυτόματη Εξαγωγή Μνήμης

Το Mem0 (προφέρεται «mem-zero») είναι ίσως το πιο δημοφιλές memory framework αυτή τη στιγμή. Η κύρια καινοτομία του; Εξάγει αυτόματα γεγονότα από συνομιλίες χωρίς να χρειάζεται να ορίσεις εσύ τι πρέπει να θυμάται. Αποφασίζει μόνο του.

Τα νούμερα μιλάνε: στο benchmark LOCOMO, το Mem0 πετυχαίνει +26% ακρίβεια σε σχέση με το OpenAI Memory, 91% χαμηλότερο latency, και 90% λιγότερα tokens. Εντυπωσιακό, σωστά;

Εγκατάσταση και Βασική Χρήση

pip install mem0ai

from openai import OpenAI
from mem0 import Memory

openai_client = OpenAI()
memory = Memory()

def chat_with_memories(message: str, user_id: str = "user_42") -> str:
    # Βήμα 1: Ανάκτηση σχετικών μνημών
    relevant_memories = memory.search(
        query=message,
        user_id=user_id,
        limit=3
    )
    memories_str = "\n".join(
        f"- {entry['memory']}" 
        for entry in relevant_memories.get("results", [])
    )

    # Βήμα 2: Δημιουργία system prompt με μνήμες
    system_prompt = f"""Είσαι ένας εξυπνος βοηθός AI. 
Απάντησε βάσει της ερώτησης και των αποθηκευμένων μνημών.

Μνήμες χρήστη:
{memories_str}"""

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": message}
    ]

    # Βήμα 3: Κλήση LLM
    response = openai_client.chat.completions.create(
        model="gpt-4.1-nano",
        messages=messages
    )
    assistant_response = response.choices[0].message.content

    # Βήμα 4: Αποθήκευση νέων μνημών
    messages.append({"role": "assistant", "content": assistant_response})
    memory.add(messages, user_id=user_id)

    return assistant_response

# Πρώτη συνομιλία
print(chat_with_memories("Δουλεύω σε startup fintech και χρησιμοποιώ Python 3.12"))

# Δεύτερη συνομιλία — θυμάται
print(chat_with_memories("Τι stack μου προτείνεις για API;"))

Πώς Λειτουργεί Εσωτερικά

Όταν καλείς memory.add(), το Mem0 εκτελεί μια αλυσίδα βημάτων που αξίζει να κατανοήσεις:

1. Εξαγωγή γεγονότων — Ένα LLM αναλύει τη συνομιλία και εντοπίζει discrete facts
2. Similarity search — Κάθε fact γίνεται embedding και συγκρίνεται με υπάρχουσες μνήμες
3. Conflict resolution — Το LLM αποφασίζει: ADD, UPDATE, DELETE ή NONE
4. Αποθήκευση — Τα αποτελέσματα σώζονται στο vector store

Υποστηρίζει πάνω από 22 vector stores (Qdrant, Pinecone, ChromaDB, pgvector) και 5+ graph databases (Neo4j, Memgraph, Kuzu). Για τοπικό development χρησιμοποιεί SQLite — δεν χρειάζεται εξωτερική υποδομή για να ξεκινήσεις.

Τρία Scopes Μνήμης

Ένα πραγματικά δυνατό χαρακτηριστικό του Mem0 είναι τα τρία επίπεδα εμβέλειας:

• User memory — Διατηρείται σε όλες τις συνομιλίες με τον ίδιο χρήστη
• Session memory — Παρακολουθεί το context μέσα σε μία μόνο συνομιλία
• Agent memory — Αποθηκεύει πληροφορίες για συγκεκριμένο agent instance

Μπορείς να τα συνδυάσεις για multi-agent, multi-user εφαρμογές. Στην πράξη, αυτό σημαίνει ότι κάθε agent μπορεί να μοιράζεται (ή να απομονώνει) ό,τι γνωρίζει για κάθε χρήστη — κάτι πολύ χρήσιμο σε enterprise σενάρια.

Μέθοδος 3: Letta — Self-Editing Memory

Αν το Mem0 είναι το «plug and play» framework, η Letta (πρώην MemGPT) πάει ένα βήμα παραπέρα. Η βασική ιδέα; Ο agent διαχειρίζεται ο ίδιος τη μνήμη του μέσω tool calls — ακριβώς όπως ένα λειτουργικό σύστημα διαχειρίζεται RAM και δίσκο.

Αντί για αυτόματη εξαγωγή (σαν το Mem0), η Letta δίνει στον agent εργαλεία για να γράψει, διαβάσει και σβήσει μνήμες. Πλήρης έλεγχος — αλλά και μεγαλύτερη πολυπλοκότητα.

Αρχιτεκτονική Μνήμης Letta

Η Letta οργανώνει τη μνήμη σε τρία ξεχωριστά επίπεδα:

• Core Memory — Πάντα ορατή στον agent, ενσωματωμένη στο system prompt. Περιλαμβάνει blocks όπως «human» (πληροφορίες χρήστη) και «persona» (ρόλος agent)
• Recall Memory — Ιστορικό συνομιλιών, προσβάσιμο μέσω search
• Archival Memory — Μακροπρόθεσμη αποθήκευση για μεγάλα datasets

Παράδειγμα Κώδικα

from letta_client import Letta
import os

# Αρχικοποίηση client
client = Letta(api_key=os.getenv("LETTA_API_KEY"))

# Δημιουργία agent με memory blocks
agent_state = client.agents.create(
    model="openai/gpt-4o",
    embedding="openai/text-embedding-3-small",
    memory_blocks=[
        {
            "label": "human",
            "value": "Ο χρήστης λέγεται Γιάννης. Δουλεύει ως backend developer.",
            "limit": 5000
        },
        {
            "label": "persona",
            "value": "Είμαι ένας AI βοηθός εξειδικευμένος σε Python και DevOps.",
            "limit": 5000
        }
    ]
)

print(f"Agent ID: {agent_state.id}")

# Αποστολή μηνύματος — ο agent θυμάται τα memory blocks
response = client.agents.messages.create(
    agent_id=agent_state.id,
    input="Τι ξέρεις για εμένα;"
)

for message in response.messages:
    print(message)

# Αργότερα: ο agent μπορεί να ενημερώσει τη μνήμη του
# μέσω tool calls (core_memory_replace, core_memory_append)
response2 = client.agents.messages.create(
    agent_id=agent_state.id,
    input="Επίσης, μόλις πέρασα σε Python 3.13 και χρησιμοποιώ uv αντί για pip"
)

for message in response2.messages:
    print(message)

Η κρίσιμη διαφορά εδώ: στη Letta, ο agent αποφασίζει μόνος του αν θα χρησιμοποιήσει core_memory_replace ή core_memory_append. Αυτό σημαίνει ότι η ποιότητα της μνήμης εξαρτάται άμεσα από τις reasoning ικανότητες του μοντέλου — κάτι που πρέπει να έχεις υπόψη σου αν χρησιμοποιείς μικρότερα μοντέλα.

Μέθοδος 4: LangMem — Μνήμη μέσα σε LangGraph

Αν ήδη χρησιμοποιείς LangGraph για τους agents σου, το LangMem είναι η πιο φυσική επιλογή. Αντί να προσθέσεις ακόμα ένα framework, ενσωματώνεις μνήμη ως tool στο υπάρχον workflow.

Σημαντική διαφορά σε σχέση με το Mem0: το LangMem δεν κάνει αυτόματη εξαγωγή μνήμης. Οι μνήμες δημιουργούνται μέσω ρητά tool calls — ο agent πρέπει να αποφασίσει ενεργά τι αξίζει να κρατήσει.

from langmem import create_manage_memory_tool, create_search_memory_tool
from langgraph.store.memory import InMemoryStore

# Δημιουργία memory store
store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small"
    }
)

# Δημιουργία memory tools
manage_memory = create_manage_memory_tool(namespace=("memories", "{user_id}"))
search_memory = create_search_memory_tool(namespace=("memories", "{user_id}"))

# Αυτά τα tools μπαίνουν στη λίστα εργαλείων του agent
tools = [manage_memory, search_memory]

# Σε ένα LangGraph workflow:
# 1. Ο agent καλεί search_memory πριν απαντήσει
# 2. Χρησιμοποιεί τα αποτελέσματα για context
# 3. Αν μάθει κάτι νέο, καλεί manage_memory για αποθήκευση

Πλεονέκτημα: πλήρης ενσωμάτωση με LangGraph workflows, χωρίς εξωτερικές εξαρτήσεις. Μειονέκτημα: αποθηκεύει μνήμες ως flat key-value — δεν υποστηρίζει entity extraction ή relationship modeling. Αν χρειάζεσαι graph-based μνήμη, κοίτα αλλού.

Σύγκριση Frameworks: Ποιο να Διαλέξεις

Ας βάλουμε τα τρία frameworks δίπλα-δίπλα, γιατί η σύγκριση βοηθάει πραγματικά:

Χαρακτηριστικό	Mem0	Letta	LangMem
Αυτόματη εξαγωγή μνήμης	Ναι	Όχι (manual)	Όχι (manual)
Graph memory	Ναι (Pro tier)	Ναι	Όχι
Framework dependency	Κανένα	Δικό του runtime	LangGraph μόνο
Deployment	Cloud ή self-hosted	Managed + self-hosted	Self-hosted
Ιδανικό για	Γρήγορο production	Πλήρη έλεγχο agent	LangGraph teams
Latency overhead	Χαμηλό	Μέτριο	Χαμηλό
Vector stores	22+	Ενσωματωμένο	LangGraph store

Γρήγορος οδηγός απόφασης:

• Θέλεις γρήγορο production χωρίς πολλή ρύθμιση; → Mem0
• Χρειάζεσαι πλήρη έλεγχο πάνω στη μνήμη; → Letta
• Ήδη δουλεύεις με LangGraph; → LangMem
• Θέλεις πρώτα να καταλάβεις πώς δουλεύει; → Ξεκίνα με τη χειροκίνητη υλοποίηση

Στρατηγικές Σχηματισμού Μνήμης

Πέρα από την επιλογή framework, υπάρχει μια αρχιτεκτονική απόφαση που συχνά αγνοείται: πότε σχηματίζεται η μνήμη;

Hot Path — Μνήμη κατά τη Συνομιλία

Η μνήμη αποθηκεύεται μέσα στη ροή της συνομιλίας, σε πραγματικό χρόνο. Κάθε μήνυμα αναλύεται αμέσως.

Πλεονέκτημα: οι μνήμες είναι αμέσως διαθέσιμες. Μειονέκτημα: προσθέτει latency σε κάθε αλληλεπίδραση — συνήθως 200-500ms extra, που μπορεί να ενοχλεί σε chatbot εφαρμογές.

Background Path — «Υποσυνείδητη» Μνήμη

Η μνήμη σχηματίζεται μετά τη συνομιλία, ασύγχρονα. Ένα background process αναλύει ολόκληρη τη συνομιλία και εξάγει insights. Κανένα latency overhead, αλλά οι μνήμες δεν είναι διαθέσιμες αμέσως. Η Letta ονομάζει αυτή τη λειτουργία «sleeptime compute» — ο agent σκέφτεται ενώ «κοιμάται». Αρκετά elegant σαν ιδέα, πρέπει να ομολογήσω.

import asyncio
from datetime import datetime

async def background_memory_extraction(
    conversation: list[dict],
    memory_store,
    user_id: str
):
    """Extract memories in the background after conversation ends."""
    # Wait a bit to avoid processing during active conversation
    await asyncio.sleep(2)

    extraction_prompt = """Analyze this completed conversation.
Extract long-term facts about the user:
- Technical preferences and stack
- Working patterns and habits
- Current projects and goals
- Pain points and challenges
Return as JSON array of objects with 'fact' and 'category' keys."""

    response = client.chat.completions.create(
        model="gpt-4.1-nano",
        messages=[
            {"role": "system", "content": extraction_prompt},
            {"role": "user", "content": str(conversation)}
        ],
        response_format={"type": "json_object"}
    )

    facts = json.loads(response.choices[0].message.content)
    for item in facts.get("facts", []):
        memory_store.add_memory(
            user_id=user_id,
            fact=item["fact"],
            category=item.get("category", "general")
        )

    print(f"[{datetime.utcnow()}] Extracted {len(facts.get('facts', []))} memories")

Production Best Practices

Η μνήμη στους AI agents δεν είναι απλώς ένα τεχνικό feature — σε production φέρνει μαζί της προκλήσεις που αξίζει να σκεφτείς εξαρχής. Ιδού τα σημαντικότερα:

1. Διαχείριση Κόστους

Κάθε memory.add() σημαίνει extra LLM calls για εξαγωγή γεγονότων και conflict resolution. Σε high-traffic εφαρμογές, αυτό μπορεί να εκτινάξει τα κόστη γρήγορα. Η λύση; Χρησιμοποίησε φθηνά μοντέλα (gpt-4.1-nano, Claude Haiku) για extraction, και κράτα τα ισχυρότερα μοντέλα για τις τελικές απαντήσεις.

2. Ιδιωτικότητα και Retention

Αν αποθηκεύεις προσωπικά δεδομένα χρηστών — ονόματα, προτιμήσεις, τεχνικό stack — πρέπει να σκεφτείς GDPR compliance. Υλοποίησε memory expiration policies και δώσε στους χρήστες τη δυνατότητα να διαγράψουν τις μνήμες τους. Αυτό δεν είναι προαιρετικό (ειδικά αν δραστηριοποιείσαι στην ΕΕ).

3. Memory Consolidation

Χωρίς consolidation, η μνήμη μεγαλώνει ανεξέλεγκτα. Χρειάζεσαι περιοδικά processes που συγχωνεύουν σχετικές μνήμες, αφαιρούν redundancies, και επιλύουν αντικρουόμενες πληροφορίες.

Το Mem0 κάνει αυτό αυτόματα μέσω conflict resolution. Σε χειροκίνητες υλοποιήσεις, πρέπει να το φτιάξεις εσύ — και δεν είναι τόσο απλό όσο ακούγεται.

4. Αξιολόγηση Ποιότητας

Πώς ξέρεις αν η μνήμη βοηθάει πραγματικά; Μέτρησε δύο πράγματα: recall accuracy (ποσοστό σωστών μνημών που ανακτήθηκαν) και precision (ποσοστό ανακτημένων μνημών που ήταν σχετικές). Ένα memory system που φέρνει πολλές αλλά άσχετες μνήμες μπορεί να είναι χειρότερο από κανένα memory system — μπερδεύει τον agent αντί να τον βοηθά.

Συχνές Ερωτήσεις (FAQ)

Ποια η διαφορά μεταξύ μνήμης AI agent και RAG pipeline;

Το RAG ανακτά πληροφορίες από στατικά έγγραφα (PDFs, knowledge bases). Η μνήμη agent αποθηκεύει και ανακαλεί δυναμικές πληροφορίες που προκύπτουν από αλληλεπιδράσεις — προτιμήσεις χρήστη, ιστορικό αποφάσεων, μαθημένα patterns. Μπορούν (και πρέπει) να συνδυαστούν: RAG για εξωτερική γνώση, memory για εξατομίκευση.

Χρειάζομαι μεγάλο context window ή μνήμη;

Δεν είναι either/or — χρειάζεσαι και τα δύο. Μεγαλύτερα context windows (200K+ tokens) βοηθάνε τη βραχυπρόθεσμη μνήμη, αλλά δεν λύνουν το πρόβλημα μεταξύ sessions. Ακόμα και με 1M tokens context, δεν μπορείς να φορτώσεις εβδομάδες συνομιλιών σε κάθε κλήση χωρίς να εκτοξεύσεις κόστη και latency. Η μακροπρόθεσμη μνήμη χρησιμοποιεί semantic search για να φέρνει μόνο ό,τι χρειάζεται.

Πόσο κοστίζουν τα memory frameworks;

Τα open-source (Mem0 OSS, Letta self-hosted) είναι δωρεάν, αλλά πρόσθεσε τα κόστη LLM calls. Κάθε memory.add() σημαίνει 1-3 extra API κλήσεις. Με gpt-4.1-nano, μιλάμε για περίπου $0.001-0.005 ανά αλληλεπίδραση — πρακτικά τίποτα για μικρά projects. Τα managed plans (Mem0 Platform, Letta Cloud) ξεκινούν δωρεάν με usage-based pricing.

Μπορώ να χρησιμοποιήσω μνήμη με Claude ή μόνο με OpenAI;

Όλα τα frameworks υποστηρίζουν πολλαπλά LLMs. Το Mem0 δουλεύει με OpenAI, Anthropic Claude, Google Gemini, και οποιοδήποτε μοντέλο μέσω LiteLLM. Η Letta υποστηρίζει Claude Sonnet/Opus, GPT-4o/4.1, Gemini, και open-weight μοντέλα. Στην πράξη, η ποιότητα εξαγωγής μνήμης εξαρτάται από τις reasoning ικανότητες του μοντέλου — τα πιο ισχυρά μοντέλα δίνουν πιο ακριβή αποτελέσματα.

Πώς σβήνω μνήμες ενός χρήστη για GDPR compliance;

Με Mem0: memory.delete_all(user_id="user_42"). Με Letta: client.agents.delete(agent_id) διαγράφει τον agent μαζί με όλη τη μνήμη του. Σε χειροκίνητες υλοποιήσεις, πρέπει να φτιάξεις εσύ το deletion endpoint. Και μην ξεχάσεις — οι μνήμες πρέπει να σβηστούν και από τυχόν backups ή replicas.