refactor: remove unused code

agent/memory/__init__.py

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

agent/memory/analysis.py

@@ -1,67 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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()