add memory module

agent/memory/__init__.py

@@ -0,0 +1,4 @@
+from .manager import MemoryManager, Message
+from .analysis import MemoryAnalyzer, MemoryAnalysis
+
+__all__ = ['MemoryManager', 'Message', 'MemoryAnalyzer', 'MemoryAnalysis'] 

agent/memory/analysis.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from langchain_core.prompts import PromptTemplate
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel
+
+class MemoryAnalysis(BaseModel):
+    is_important: bool
+    formatted_memory: Optional[str] = None
+
+MEMORY_ANALYSIS_PROMPT = PromptTemplate.from_template("""Extract and format important personal facts about the user from their message.
+Focus on the actual information, not meta-commentary or requests.
+
+Important facts include:
+- Personal details (name, age, location)
+- Professional info (job, education, skills)
+- Preferences (likes, dislikes, favorites)
+- Life circumstances (family, relationships)
+- Significant experiences or achievements
+- Personal goals or aspirations
+
+Rules:
+1. Only extract actual facts, not requests or commentary
+2. Convert facts into clear, third-person statements
+3. If no actual facts are present, mark as not important
+4. Remove conversational elements and focus on core information
+
+Examples:
+Input: "Hey, could you remember that I love Star Wars?"
+Output: {
+    "is_important": true,
+    "formatted_memory": "Loves Star Wars"
+}
+
+Input: "Can you remember my details for next time?"
+Output: {
+    "is_important": false,
+    "formatted_memory": null
+}
+
+Message: {message}
+Output:""")
+
+class MemoryAnalyzer:
+    def __init__(self, temperature: float = 0.1):
+        self.llm = ChatOpenAI(temperature=temperature)
+    
+    async def analyze_memory(self, message: str) -> MemoryAnalysis:
+        """Analyze a message to determine importance and format if needed."""
+        prompt = MEMORY_ANALYSIS_PROMPT.format(message=message)
+        response = await self.llm.ainvoke(prompt)
+        
+        # Parse the response into a MemoryAnalysis object
+        try:
+            # Extract the JSON-like content from the response
+            content = response.content
+            if isinstance(content, str):
+                # Convert string representation to dict
+                import json
+                content = json.loads(content)
+            
+            return MemoryAnalysis(
+                is_important=content.get("is_important", False),
+                formatted_memory=content.get("formatted_memory")
+            )
+        except Exception as e:
+            # If parsing fails, return a safe default
+            return MemoryAnalysis(is_important=False, formatted_memory=None) 

agent/memory/example.py

@@ -0,0 +1,52 @@
+from datetime import datetime
+from .manager import MemoryManager, Message
+from .analysis import MemoryAnalyzer
+import uuid
+
+async def main():
+    # Initialize the memory system
+    memory_manager = MemoryManager(
+        qdrant_url="http://localhost:6333",
+        sqlite_path="data/short_term.db"
+    )
+    memory_analyzer = MemoryAnalyzer()
+    
+    try:
+        # Example: Store a message in short-term memory
+        message = Message(
+            content="I really enjoy programming in Python and building AI applications.",
+            type="human",
+            timestamp=datetime.now()
+        )
+        await memory_manager.store_short_term(message)
+        
+        # Analyze the message for long-term storage
+        analysis = await memory_analyzer.analyze_memory(message.content)
+        
+        if analysis.is_important and analysis.formatted_memory:
+            # Check for similar existing memories
+            similar = memory_manager.find_similar_memory(analysis.formatted_memory)
+            
+            if not similar:
+                # Store in long-term memory if no similar memory exists
+                memory_manager.store_long_term(
+                    text=analysis.formatted_memory,
+                    metadata={
+                        "id": str(uuid.uuid4()),
+                        "timestamp": datetime.now().isoformat(),
+                        "source_message": message.content
+                    }
+                )
+        
+        # Retrieve recent messages from short-term memory
+        recent_messages = memory_manager.get_recent_messages(limit=5)
+        print("Recent messages:")
+        for msg in recent_messages:
+            print(f"- {msg.timestamp}: {msg.content}")
+            
+    finally:
+        memory_manager.close()
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

agent/memory/manager.py

@@ -0,0 +1,105 @@
+from datetime import datetime
+import sqlite3
+import uuid
+from typing import Optional, List
+from pydantic import BaseModel
+from sentence_transformers import SentenceTransformer
+from qdrant_client import QdrantClient
+from qdrant_client.models import PointStruct
+import os
+
+class MemoryAnalysis(BaseModel):
+    is_important: bool
+    formatted_memory: Optional[str] = None
+
+class Message(BaseModel):
+    content: str
+    type: str  # "human" or "ai"
+    timestamp: datetime
+
+class MemoryManager:
+    SIMILARITY_THRESHOLD = 0.9
+    
+    def __init__(self, qdrant_url: str = "http://localhost:6333", sqlite_path: str = "data/short_term.db"):
+        # Initialize vector store (Qdrant)
+        self.model = SentenceTransformer("all-MiniLM-L6-v2")
+        self.qdrant = QdrantClient(url=qdrant_url)
+        
+        # Ensure the collection exists
+        try:
+            self.qdrant.get_collection("memories")
+        except:
+            self.qdrant.create_collection(
+                collection_name="memories",
+                vectors_config={
+                    "size": self.model.get_sentence_embedding_dimension(),
+                    "distance": "Cosine"
+                }
+            )
+        
+        # Initialize SQLite for short-term memory
+        os.makedirs(os.path.dirname(sqlite_path), exist_ok=True)
+        self.sqlite_conn = sqlite3.connect(sqlite_path)
+        self._init_sqlite()
+    
+    def _init_sqlite(self):
+        """Initialize SQLite tables for short-term memory."""
+        cursor = self.sqlite_conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS conversations (
+                id TEXT PRIMARY KEY,
+                content TEXT NOT NULL,
+                type TEXT NOT NULL,
+                timestamp DATETIME NOT NULL
+            )
+        """)
+        self.sqlite_conn.commit()
+    
+    async def store_short_term(self, message: Message) -> None:
+        """Store a message in short-term memory (SQLite)."""
+        cursor = self.sqlite_conn.cursor()
+        cursor.execute(
+            "INSERT INTO conversations (id, content, type, timestamp) VALUES (?, ?, ?, ?)",
+            (str(uuid.uuid4()), message.content, message.type, message.timestamp.isoformat())
+        )
+        self.sqlite_conn.commit()
+    
+    def get_recent_messages(self, limit: int = 10) -> List[Message]:
+        """Retrieve recent messages from short-term memory."""
+        cursor = self.sqlite_conn.cursor()
+        cursor.execute(
+            "SELECT content, type, timestamp FROM conversations ORDER BY timestamp DESC LIMIT ?",
+            (limit,)
+        )
+        return [
+            Message(content=row[0], type=row[1], timestamp=datetime.fromisoformat(row[2]))
+            for row in cursor.fetchall()
+        ]
+    
+    def store_long_term(self, text: str, metadata: dict) -> None:
+        """Store a memory in long-term memory (Qdrant)."""
+        embedding = self.model.encode(text)
+        self.qdrant.upsert(
+            collection_name="memories",
+            points=[PointStruct(
+                id=metadata["id"],
+                vector=embedding.tolist(),
+                payload={"text": text, **metadata}
+            )]
+        )
+    
+    def find_similar_memory(self, text: str) -> Optional[str]:
+        """Find similar existing memory using cosine similarity."""
+        embedding = self.model.encode(text)
+        results = self.qdrant.search(
+            collection_name="memories",
+            query_vector=embedding.tolist(),
+            limit=1
+        )
+        if results and results[0].score > self.SIMILARITY_THRESHOLD:
+            return results[0].payload["text"]
+        return None
+    
+    def close(self):
+        """Close database connections."""
+        self.sqlite_conn.close() 

docker-compose.yml

@@ -0,0 +1,23 @@
+version: "3.8"
+
+services:
+  qdrant:
+    image: qdrant/qdrant:latest
+    ports:
+      - "6333:6333"
+    volumes:
+      - ./data/long_term_memory:/qdrant/storage
+    restart: unless-stopped
+
+  app:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app
+      - ./data/short_term_memory:/app/data
+    environment:
+      - QDRANT_URL=http://qdrant:6333
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+    depends_on:
+      - qdrant