working

Author: truemagic-coder

README.md

@@ -71,7 +71,6 @@ Build your AI agents in three lines of code!
 * [Python](https://python.org) - Programming Language
 * [OpenAI](https://openai.com) - AI Model Provider
 * [MongoDB](https://mongodb.com) - Conversational History (optional)
-* [Zep Cloud](https://getzep.com) - Conversational Memory (optional)
 * [Pinecone](https://pinecone.io) - Knowledge Base (optional)
 * [AgentiPy](https://agentipy.fun) - Solana Ecosystem (optional)
 * [Zapier](https://zapier.com) - App Integrations (optional)
@@ -377,16 +376,6 @@ config = {
 }
 ```
 
-### Conversational Memory
-
-```python
-config = {
-    "zep": {
-        "api_key": "your-zep-cloud-api-key",
-    },
-}
-```
-
 ### Observability and Tracing
 
 ```python
@@ -421,16 +410,15 @@ config = {
 }
 ```
 
-### Knowledge Base
-
-The Knowledge Base (KB) is meant to store text values and/or PDFs (extracts text) - can handle very large PDFs.
+### Knowledge Base & Conversational Memory
 
 ```python
 config = {
     "knowledge_base": {
         "pinecone": {
             "api_key": "your-pinecone-api-key",
             "index_name": "your-pinecone-index-name",
+            "use_reranking": True # optional - but increases better matching - requires Pinecone Standard
         }
     },
     "mongo": {

docs/index.rst

@@ -310,17 +310,6 @@ Conversational History - Optional
       },
    }
 
-Conversational Memory - Optional
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code-block:: python
-   
-   config = {
-      "zep": {
-         "api_key": "your-zep-api-key",
-      },
-   }
-
 Observability and Tracing - Optional
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -361,7 +350,7 @@ Gemini - Optional
    }
 
 
-Knowledge Base - Optional
+Knowledge Base & Conversational Memory - Optional
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The Knowledge Base (KB) is meant to store text values and/or small PDFs.

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solana-agent"
-version = "29.2.0-dev80"
+version = "30.0.0"
 description = "AI Agents for Solana"
 authors = ["Bevan Hunt <bevan@bevanhunt.com>"]
 license = "MIT"
@@ -27,7 +27,6 @@ python = ">=3.12,<4.0"
 openai = "1.79.0"
 pydantic = ">=2"
 pymongo = "4.13.0"
-zep-cloud = "2.12.3"
 instructor = "1.8.2"
 pinecone = "6.0.2"
 llama-index-core = "0.12.37"

pyproject.toml

@@ -136,21 +136,9 @@ def create_from_config(config: Dict[str, Any]) -> QueryService:
             )
 
         # Create repositories
-        memory_provider = None
-
-        if "zep" in config and "mongo" in config:
-            memory_provider = MemoryRepository(
-                mongo_adapter=db_adapter, zep_api_key=config["zep"].get("api_key")
-            )
-
-        if "mongo" in config and "zep" not in config:
-            memory_provider = MemoryRepository(mongo_adapter=db_adapter)
-
-        if "zep" in config and "mongo" not in config:
-            if "api_key" not in config["zep"]:
-                raise ValueError("Zep API key is required.")
-            memory_provider = MemoryRepository(zep_api_key=config["zep"].get("api_key"))
+        memory_provider = MemoryRepository(mongo_adapter=db_adapter)
 
+        # Create guardrails
         guardrail_config = config.get("guardrails", {})
         input_guardrails: List[InputGuardrail] = SolanaAgentFactory._create_guardrails(
             guardrail_config.get("input", [])

solana_agent/factories/agent_factory.py

@@ -1,9 +1,6 @@
 import logging  # Import logging
-from copy import deepcopy
 from typing import List, Dict, Any, Optional, Tuple
 from datetime import datetime, timezone
-from zep_cloud.client import AsyncZep as AsyncZepCloud
-from zep_cloud.types import Message
 from solana_agent.interfaces.providers.memory import MemoryProvider
 from solana_agent.adapters.mongodb_adapter import MongoDBAdapter
 
@@ -12,12 +9,11 @@
 
 
 class MemoryRepository(MemoryProvider):
-    """Combined Zep and MongoDB implementation of MemoryProvider."""
+    """MongoDB implementation of MemoryProvider."""
 
     def __init__(
         self,
         mongo_adapter: Optional[MongoDBAdapter] = None,
-        zep_api_key: Optional[str] = None,
     ):
         """Initialize the combined memory provider."""
         if not mongo_adapter:
@@ -36,13 +32,8 @@ def __init__(
             except Exception as e:
                 logger.error(f"Error initializing MongoDB: {e}")  # Use logger.error
 
-        self.zep = None
-        # Initialize Zep
-        if zep_api_key:
-            self.zep = AsyncZepCloud(api_key=zep_api_key)
-
     async def store(self, user_id: str, messages: List[Dict[str, Any]]) -> None:
-        """Store messages in both Zep and MongoDB."""
+        """Store messages in MongoDB."""
         if not user_id:
             raise ValueError("User ID cannot be None or empty")
         if not messages or not isinstance(messages, list):
@@ -86,56 +77,22 @@ async def store(self, user_id: str, messages: List[Dict[str, Any]]) -> None:
             except Exception as e:
                 logger.error(f"MongoDB storage error: {e}")  # Use logger.error
 
-        # Store in Zep
-        if not self.zep:
-            return
-
-        # Convert messages to Zep format
-        zep_messages = []
-        for msg in messages:
-            if "role" in msg and "content" in msg:
-                content = self._truncate(deepcopy(msg["content"]))
-                zep_msg = Message(
-                    role=msg["role"],
-                    content=content,
-                    role_type=msg["role"],
-                )
-                zep_messages.append(zep_msg)
-
-        # Add messages to Zep memory
-        if zep_messages:
-            try:
-                await self.zep.memory.add(session_id=user_id, messages=zep_messages)
-            except Exception:
-                try:
-                    try:
-                        await self.zep.user.add(user_id=user_id)
-                    except Exception as e:
-                        logger.error(
-                            f"Zep user addition error: {e}"
-                        )  # Use logger.error
-
-                    try:
-                        await self.zep.memory.add_session(
-                            session_id=user_id, user_id=user_id
-                        )
-                    except Exception as e:
-                        logger.error(
-                            f"Zep session creation error: {e}"
-                        )  # Use logger.error
-                    await self.zep.memory.add(session_id=user_id, messages=zep_messages)
-                except Exception as e:
-                    logger.error(f"Zep memory addition error: {e}")  # Use logger.error
-                    return
-
     async def retrieve(self, user_id: str) -> str:
-        """Retrieve memory context from Zep only."""
+        """Retrieve memory context from MongoDB."""
         try:
             memories = ""
-            if self.zep:
-                memory = await self.zep.memory.get(session_id=user_id)
-                if memory and memory.context:
-                    memories = memory.context
+            if self.mongo:
+                query = {"user_id": user_id}
+                sort = [("timestamp", -1)]
+                limit = 3
+                skip = 0
+                results = self.mongo.find(
+                    self.collection, query, sort=sort, limit=limit, skip=skip
+                )
+                if results:
+                    for result in results:
+                        memories += f"User: {result.get('user_message')}\n"
+                        memories += f"Assistant: {result.get('assistant_message')}\n"
             return memories
 
         except Exception as e:
@@ -150,19 +107,6 @@ async def delete(self, user_id: str) -> None:
             except Exception as e:
                 logger.error(f"MongoDB deletion error: {e}")  # Use logger.error
 
-        if not self.zep:
-            return
-
-        try:
-            await self.zep.memory.delete(session_id=user_id)
-        except Exception as e:
-            logger.error(f"Zep memory deletion error: {e}")  # Use logger.error
-
-        try:
-            await self.zep.user.delete(user_id=user_id)
-        except Exception as e:
-            logger.error(f"Zep user deletion error: {e}")  # Use logger.error
-
     def find(
         self,
         collection: str,
@@ -186,22 +130,3 @@ def count_documents(self, collection: str, query: Dict) -> int:
         if not self.mongo:
             return 0
         return self.mongo.count_documents(collection, query)
-
-    def _truncate(self, text: str, limit: int = 2500) -> str:
-        """Truncate text to be within limits."""
-        if text is None:
-            raise AttributeError("Cannot truncate None text")
-
-        if not text:
-            return ""
-
-        if len(text) <= limit:
-            return text
-
-        # Try to truncate at last period before limit
-        last_period = text.rfind(".", 0, limit)
-        if last_period > 0:
-            return text[: last_period + 1]
-
-        # If no period found, truncate at limit and add ellipsis
-        return text[: limit - 3] + "..."

solana_agent/repositories/memory.py

@@ -78,7 +78,6 @@ async def search(
         # Only return nodes that match user_id
         nodes = []
         for nid in node_ids:
-            print(f"Node ID: {nid}")
             node = await self.graph.get_node(nid)
             if node and node.get("user_id") == user_id:
                 nodes.append(node)