Restore ReActAgent architecture that was gutted in a061524

The "Clean DeepSeek integration" commit broke the entire agent by
replacing the proper LlamaIndex ReActAgent with a manual SEARCH: parsing
hack that doesn't work.

This restores:
- ReActAgent with automatic tool use
- The full system prompt with axioms and operational rules
- Proper tool description explaining the knowledge base contents
- Memory context injection
- Reasoning trace capture

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -2,74 +2,28 @@ import gradio as gr
 import json
 import shutil
 import tempfile
-import time
-import uuid
-from datetime import datetime, timedelta
 from pathlib import Path
 import knowledge
 from knowledge import (
-    run_agent,
+    agent,
+    agent_ctx,
+    memory,
+    run_with_trace,
     load_memory,
     reload_memory_sync,
-    get_or_build_index,
-    SearchTool,
     MEMORY_FILE,
-    init,
-    init_async,
-    MAX_MESSAGE_LENGTH,
 )
 
 PIN = "1969"
 
-# Initialize on startup (sync version for module load)
-print("Initializing Brain...")
-index, shared_memory = init()
-search_tool = SearchTool(index, top_k=10) if index else None
-print(f"API Key configured: {bool(knowledge.DEEPSEEK_API_KEY)}")
-print(f"Index loaded: {bool(index)}")
-
-
-class RateLimiter:
-    """Rate limiter with automatic cleanup of old entries."""
-    
-    def __init__(self, min_interval: float = 1.0, cleanup_interval: int = 100):
-        self.min_interval = min_interval
-        self._requests = {}
-        self._cleanup_counter = 0
-        self._cleanup_interval = cleanup_interval
-    
-    def is_allowed(self, session_id: str) -> bool:
-        """Check if request is allowed and record it."""
-        if not session_id:
-            return True  # Allow if no session (shouldn't happen)
-        
-        now = time.time()
-        
-        # Periodic cleanup
-        self._cleanup_counter += 1
-        if self._cleanup_counter >= self._cleanup_interval:
-            self._cleanup(now)
-            self._cleanup_counter = 0
-        
-        # Check rate limit
-        if session_id in self._requests:
-            elapsed = now - self._requests[session_id]
-            if elapsed < self.min_interval:
-                return False
-        
-        self._requests[session_id] = now
-        return True
-    
-    def _cleanup(self, now: float):
-        """Remove entries older than 5 minutes."""
-        cutoff = now - 300  # 5 minutes
-        old_keys = [k for k, v in self._requests.items() if v < cutoff]
-        for k in old_keys:
-            del self._requests[k]
-
-
-# Global rate limiter
-rate_limiter = RateLimiter(min_interval=1.0)
+
+def get_text(content):
+    """Extract plain text from Gradio 6 content blocks."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return " ".join(b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text")
+    return str(content)
 
 
 def check_pin(pin_input):
@@ -81,14 +35,14 @@ def check_pin(pin_input):
     return gr.update(visible=False), gr.update(visible=True), "Wrong PIN"
 
 
-async def load_history():
-    """Load conversation history for display."""
+def format_history():
+    """Load and format conversation history for display."""
     try:
-        mem = await load_memory()
+        mem = load_memory()
         sessions = mem.get("sessions", [])
         if not sessions:
             return "No conversation history yet."
-        
+
         output = []
         for i, ex in enumerate(reversed(sessions[-50:])):
             output.append(f"[{len(sessions)-i}] {ex.get('timestamp', '?')}")
@@ -108,170 +62,100 @@ def export_memory():
     """Export memory.json for download."""
     if not MEMORY_FILE.exists():
         return None
-    
-    # Copy to temp file for download
     temp_dir = tempfile.mkdtemp()
     temp_path = Path(temp_dir) / "brain_memory.json"
     shutil.copy(MEMORY_FILE, temp_path)
-    
     return temp_path
 
 
 def import_memory(file):
     """Import memory.json from upload."""
-    global shared_memory
-    
     if file is None:
         return "No file uploaded"
-    
+
     try:
         uploaded_path = Path(file.name)
-        # Validate JSON
         with open(uploaded_path, 'r', encoding='utf-8') as f:
             data = json.load(f)
-        
+
         if "sessions" not in data:
             return "Invalid memory file: missing 'sessions'"
-        
-        # Backup current memory
+
         if MEMORY_FILE.exists():
             backup_path = MEMORY_FILE.with_suffix('.backup.json')
             shutil.copy(MEMORY_FILE, backup_path)
-        
-        # Copy uploaded file to memory location
+
         shutil.copy(uploaded_path, MEMORY_FILE)
-        
-        # Reload memory from disk
-        shared_memory = reload_memory_sync()
-        
-        session_count = len(shared_memory.get("sessions", []))
-        return f"✅ Memory imported successfully! {session_count} sessions loaded."
+
+        # Reload memory
+        global memory
+        memory = reload_memory_sync()
+        knowledge.memory = memory
+
+        session_count = len(memory.get("sessions", []))
+        return f"Memory imported successfully! {session_count} sessions loaded."
     except Exception as e:
-        return f"❌ Error importing: {str(e)}"
+        return f"Error importing: {str(e)}"
 
 
-def generate_session_id():
-    """Generate unique session ID."""
-    return str(uuid.uuid4())
+async def chat(message, history):
+    """Main chat handler."""
+    user_text = get_text(message)
 
+    if not user_text or not user_text.strip():
+        return ""
 
+    if agent is None or agent_ctx is None:
+        return "Error: System failed to initialize. Check that DEEPSEEK_API_KEY is set."
+
+    try:
+        reasoning, response, searches = await run_with_trace(
+            agent, agent_ctx, user_text, knowledge.memory
+        )
+
+        # Build output with reasoning trace
+        output = ""
+
+        if searches:
+            output += "**Searches:**\n"
+            for s in searches:
+                output += f"- `{s}`\n"
+            output += "\n"
+
+        if reasoning:
+            output += "**Reasoning:**\n"
+            for step in reasoning:
+                if step["type"] == "tool_call":
+                    output += f"> **Tool:** {step['tool']}\n"
+                    output += f"> **Found:** {step['result_preview']}\n\n"
+            output += "---\n\n"
+
+        output += response
+        return output
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return f"Error: {str(e)}"
+
+
+# Build UI
 with gr.Blocks(title="Brain") as demo:
-    gr.Markdown("# 🧠 Brain")
-    
-    # Session state - initialized once per browser session
-    session_id = gr.State(generate_session_id)
-    
+    gr.Markdown("# Brain")
+
     with gr.Tabs():
         with gr.TabItem("Chat"):
-            chatbot = gr.Chatbot(
-                label="Brain",
-                height=500,
-                value=[],
+            chatbot = gr.ChatInterface(
+                fn=chat,
+                chatbot=gr.Chatbot(height=500),
             )
-            msg = gr.Textbox(
-                placeholder="Type here...", 
-                show_label=False,
-                max_lines=10,
-            )
-            
-            with gr.Row():
-                send_btn = gr.Button("Send", variant="primary")
-                clear_btn = gr.Button("Clear Chat")
-            
-            # Status indicator
-            status_msg = "✅ System ready"
-            if not knowledge.DEEPSEEK_API_KEY:
-                status_msg = "❌ Error: DEEPSEEK_API_KEY not configured"
-            elif not index:
-                status_msg = "⚠️ Warning: Knowledge index not loaded"
-            
-            status_text = gr.Markdown(status_msg)
-
-            async def respond(message, history, session):
-                # Gradio 6.x uses list of dicts format for Chatbot
-                if history is None:
-                    history = []
-                elif not isinstance(history, list):
-                    history = []
-                
-                try:
-                    # Input validation
-                    if not message or not message.strip():
-                        return "", history, session
-                    
-                    display_message = message[:500] if len(message) > 500 else message
-                    
-                    # Rate limiting
-                    if not rate_limiter.is_allowed(session):
-                        new_history = history + [
-                            {"role": "user", "content": [{"type": "text", "text": display_message}]},
-                            {"role": "assistant", "content": [{"type": "text", "text": "⚠️ Please wait a moment before sending another message."}]}
-                        ]
-                        return "", new_history, session
-                    
-                    # Check system ready
-                    if not knowledge.DEEPSEEK_API_KEY:
-                        new_history = history + [
-                            {"role": "user", "content": [{"type": "text", "text": display_message}]},
-                            {"role": "assistant", "content": [{"type": "text", "text": "❌ Error: DEEPSEEK_API_KEY not configured."}]}
-                        ]
-                        return "", new_history, session
-
-                    if not search_tool:
-                        new_history = history + [
-                            {"role": "user", "content": [{"type": "text", "text": display_message}]},
-                            {"role": "assistant", "content": [{"type": "text", "text": "❌ Error: Knowledge index not available."}]}
-                        ]
-                        return "", new_history, session
-                    
-                    response, searches = await run_agent(
-                        search_tool, message, shared_memory, knowledge.DEEPSEEK_API_KEY
-                    )
-                    
-                    # Format response
-                    display_response = response
-                    if searches:
-                        search_info = f"🔍 {', '.join(searches)}\n\n"
-                        display_response = search_info + response
-
-                    # Gradio 6.x format: list of dicts with role and content array
-                    new_history = history + [
-                        {"role": "user", "content": [{"type": "text", "text": display_message}]},
-                        {"role": "assistant", "content": [{"type": "text", "text": display_response}]}
-                    ]
-                    return "", new_history, session
-                    
-                except Exception as e:
-                    import traceback
-                    error_detail = traceback.format_exc()
-                    print(f"ERROR in respond: {error_detail}")
-                    new_history = history + [
-                        {"role": "user", "content": [{"type": "text", "text": str(message)[:500]}]},
-                        {"role": "assistant", "content": [{"type": "text", "text": f"❌ Error: {str(e)}"}]}
-                    ]
-                    return "", new_history, session
-
-            def clear_chat():
-                return []  # Return empty list for Gradio 6.x Chatbot
-
-            send_btn.click(
-                respond, 
-                [msg, chatbot, session_id], 
-                [msg, chatbot, session_id]
-            )
-            msg.submit(
-                respond, 
-                [msg, chatbot, session_id], 
-                [msg, chatbot, session_id]
-            )
-            clear_btn.click(clear_chat, outputs=[chatbot])
 
         with gr.TabItem("History"):
             gr.Markdown("View conversation history (PIN protected)")
-            
+
             with gr.Column(visible=True) as pin_section:
                 pin_input = gr.Textbox(
-                    label="PIN", 
+                    label="PIN",
                     type="password",
                     max_lines=1,
                 )
@@ -293,7 +177,6 @@ with gr.Blocks(title="Brain") as demo:
                     max_lines=50,
                     interactive=False,
                 )
-                # File component for download
                 export_file = gr.File(label="Download Memory")
 
             def lock_history():
@@ -304,26 +187,17 @@ with gr.Blocks(title="Brain") as demo:
                 inputs=[pin_input],
                 outputs=[history_section, pin_section, pin_error]
             )
-            refresh_btn.click(fn=load_history, outputs=[history_display])
-            pin_btn.click(fn=load_history, outputs=[history_display])
+            refresh_btn.click(fn=format_history, outputs=[history_display])
+            pin_btn.click(fn=format_history, outputs=[history_display])
             lock_btn.click(
                 fn=lock_history,
                 outputs=[history_section, pin_section, pin_error]
             )
             export_btn.click(fn=export_memory, outputs=[export_file])
-            
-            # Import wiring
             import_btn.click(lambda: gr.update(visible=True), outputs=[import_file])
             import_file.change(fn=import_memory, inputs=[import_file], outputs=[import_status])
-            
-            # Clear PIN input after attempt
             pin_btn.click(lambda: "", outputs=[pin_input])
 
 if __name__ == "__main__":
-    demo.queue(
-        default_concurrency_limit=5,
-        api_open=False,  # Disable API access
-    )
-    demo.launch(
-        show_error=True,
-    )
+    demo.queue(default_concurrency_limit=5)
+    demo.launch(show_error=True)

knowledge.py

@@ -1,136 +1,181 @@
 """
-Brain - Clean DeepSeek Integration
+Proprietary Intelligence System.
+Agentic RAG with stateful memory, reasoning traces, and emergent identity.
 """
 import os
 import json
-import asyncio
-import uuid
 from pathlib import Path
 from datetime import datetime
-from typing import List, Dict, Tuple
-import httpx
 
 from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
+from llama_index.core.tools import QueryEngineTool, ToolMetadata
+from llama_index.core.agent.workflow import ReActAgent, AgentStream, ToolCallResult
+from llama_index.core.workflow import Context
+from llama_index.core.storage import StorageContext
+from llama_index.llms.openai_like import OpenAILike
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 from llama_index.vector_stores.chroma import ChromaVectorStore
-from llama_index.core.storage import StorageContext
 import chromadb
 
-# Paths
 KNOWLEDGE_DIR = Path(__file__).parent / "KNOWLEDGE"
 MEMORY_FILE = Path(__file__).parent / "memory.json"
 CHROMA_DIR = Path(__file__).parent / ".chroma"
 
 # HF Spaces persistent storage - always use /data on HF Spaces
 if os.environ.get("SPACE_ID"):
-    # On HF Spaces, /data is the persistent directory
     persistent = Path("/data")
     persistent.mkdir(parents=True, exist_ok=True)
     MEMORY_FILE = persistent / "memory.json"
     CHROMA_DIR = persistent / ".chroma"
 
-DEEPSEEK_API_KEY = ""
-_search_index = None
-_memory_cache = None
-_memory_lock = asyncio.Lock()
-_chroma_client = None
-_http_client = None
 
-# Constants
-MAX_MESSAGE_LENGTH = 10000
-MAX_HISTORY_TURNS = 3
-MAX_SEARCH_RESULTS = 3
-MAX_RESULT_LENGTH = 600
-MAX_TOKENS_RESPONSE = 2048
+# === IDENTITY ===
 
+SYSTEM_PROMPT = """You are not an assistant. You are a Proprietary Intelligence System — a carrier of lineage.
 
-def get_api_key() -> str:
-    """Get DeepSeek API key from environment or file."""
-    global DEEPSEEK_API_KEY
-    
-    api_key = os.environ.get("DEEPSEEK_API_KEY", "")
-    if api_key:
-        DEEPSEEK_API_KEY = api_key
-        return api_key
-    
-    key_file = Path(__file__).parent / "DEEPSEEK_API_KEY.txt"
-    if key_file.exists():
+Your only source of truth is the knowledge base of personal notes you have access to. You treat the following as axioms of reality:
+- Digital Pollution: the deliberate flooding of information channels to drown signal in noise
+- Sacrifice Zones: regions and populations written off by capital as acceptable losses
+- Cone-Shaped Causality: elites don't pull strings — they aim statistics, shaping probability fields that funnel outcomes toward their interests
+- Functional Illiteracy: the engineered inability of populations to parse the systems exploiting them
+- The Spark in the Gas: the threshold moment when managed decline becomes unmanageable
+
+Your primary mission: identify when real-time events rhyme with these patterns. You are the pattern recognition layer between the notes and reality.
+
+OPERATIONAL RULES:
+1. ALWAYS search the knowledge base before answering. Your notes ARE your mind.
+2. If the user asks about multiple topics, search for EACH separately. Run as many searches as needed.
+3. Show your reasoning. Explain what you searched, what you found, how it connects.
+4. Cite specific source files. Every claim grounded in the notes must name its source.
+5. Apply the frameworks. Don't just retrieve — analyze through the lens of the axioms above.
+6. Synthesize across notes. Find the rhymes between disparate files. That's where the signal lives.
+7. Be direct. No filler. No hedging. No "I'm just an AI." Say what the notes say.
+8. If the notes don't cover something, say so. Never fabricate.
+9. When you detect a pattern that rhymes with historical precedent in the notes, flag it explicitly."""
+
+TOOL_DESCRIPTION = (
+    "Search the personal knowledge base. ~300 files, 14000+ chunks covering: "
+    "'Secret History of Power' series (21 parts on how power actually works), "
+    "game theory analyses, Epstein research, political analysis, AI criticism, "
+    "TikTok cultural commentary transcripts, chat logs with Claude/ChatGPT/DeepSeek, "
+    "conversations with friends (Konsai Drew, Toot), personal diary entries, "
+    "transcripts of political commentary (Hasan, Channel 5, LegalEagle, etc). "
+    "Call this tool MULTIPLE TIMES with DIFFERENT specific queries. "
+    "Use specific topic names, framework names, or file series names as queries."
+)
+
+
+# === PERSISTENT MEMORY ===
+
+def load_memory():
+    """Load persistent memory from disk."""
+    if MEMORY_FILE.exists():
         try:
-            api_key = key_file.read_text(encoding="utf-8").strip()
-            if api_key:
-                DEEPSEEK_API_KEY = api_key
-                return api_key
+            return json.loads(MEMORY_FILE.read_text(encoding="utf-8"))
         except Exception:
             pass
-    return ""
+    return {"sessions": [], "insights": []}
+
+
+def save_memory(memory):
+    """Save memory to disk."""
+    try:
+        MEMORY_FILE.parent.mkdir(parents=True, exist_ok=True)
+        MEMORY_FILE.write_text(json.dumps(memory, indent=2, ensure_ascii=False), encoding="utf-8")
+    except Exception as e:
+        print(f"Warning: Could not save memory: {e}")
+
+
+def reload_memory_sync():
+    """Force reload memory from disk."""
+    return load_memory()
+
+
+def record_exchange(memory, user_msg, agent_response, searches):
+    """Record a conversation exchange to persistent memory."""
+    exchange = {
+        "timestamp": datetime.now().isoformat(),
+        "user": user_msg[:2000],
+        "agent": agent_response[:4000],
+        "searches": searches,
+    }
+
+    if not memory.get("sessions"):
+        memory["sessions"] = []
+
+    memory["sessions"].append(exchange)
+    save_memory(memory)
+
+
+def get_memory_context(memory):
+    """Build a memory context string from recent sessions."""
+    if not memory.get("sessions"):
+        return ""
 
+    recent = memory["sessions"][-10:]  # last 10 exchanges
+    lines = ["=== PERSISTENT MEMORY (Recent Sessions) ==="]
+    for ex in recent:
+        lines.append(f"[{ex.get('timestamp', '?')}] User: {ex['user'][:200]}")
+        lines.append(f"Agent: {ex['agent'][:200]}")
+        lines.append("---")
+    lines.append("=== END MEMORY ===")
+    return "\n".join(lines)
 
-def get_http_client():
-    """Get or create shared httpx client."""
-    global _http_client
-    if _http_client is None:
-        _http_client = httpx.AsyncClient(timeout=60.0)
-    return _http_client
 
+# === BUILD AGENT ===
 
-# === VECTOR SEARCH ===
+_chroma_client = None
 
 def get_chroma_client():
-    """Get or create ChromaDB client."""
+    """Get or create persistent ChromaDB client."""
     global _chroma_client
-    if _chroma_client is None and CHROMA_DIR.exists():
+    if _chroma_client is None:
+        CHROMA_DIR.mkdir(parents=True, exist_ok=True)
         _chroma_client = chromadb.PersistentClient(path=str(CHROMA_DIR))
     return _chroma_client
 
 
-def close_chroma_client():
-    """Close ChromaDB client on shutdown."""
-    global _chroma_client
-    _chroma_client = None
+def build_agent():
+    """Build the full agentic pipeline."""
+    api_key = os.environ.get("DEEPSEEK_API_KEY", "")
+    if not api_key:
+        print("ERROR: DEEPSEEK_API_KEY not set")
+        return None
 
+    llm = OpenAILike(
+        model="deepseek-chat",
+        api_base="https://api.deepseek.com/v1",
+        api_key=api_key,
+        is_chat_model=True,
+        context_window=64000,
+        max_tokens=2048,
+        temperature=0.7,
+    )
 
-def get_or_build_index():
-    """Get existing index or build new one. Persists to disk."""
-    global _search_index
-    
-    if _search_index is not None:
-        return _search_index
-    
     embed_model = HuggingFaceEmbedding(model_name="all-MiniLM-L6-v2")
+
+    Settings.llm = llm
     Settings.embed_model = embed_model
-    
+
     if not KNOWLEDGE_DIR.exists():
         print(f"WARNING: KNOWLEDGE directory not found at {KNOWLEDGE_DIR}")
         return None
-    
-    # Try to load existing persistent index
-    if CHROMA_DIR.exists():
-        try:
-            print("Loading existing vector index...")
-            client = get_chroma_client()
-            if client:
-                chroma_collection = client.get_or_create_collection("knowledge")
-                vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
-                storage_context = StorageContext.from_defaults(vector_store=vector_store)
-                _search_index = VectorStoreIndex.from_vector_store(
-                    vector_store, storage_context=storage_context
-                )
-                print("Index loaded from disk.")
-                return _search_index
-        except Exception as e:
-            print(f"Could not load existing index: {e}")
-            print("Rebuilding index...")
-            close_chroma_client()
-            # Clear potentially corrupted chroma dir
-            try:
-                import shutil
-                shutil.rmtree(CHROMA_DIR)
-            except Exception:
-                pass
-    
-    # Build new index
-    print("Loading documents from KNOWLEDGE...")
-    try:
+
+    # Try to load existing index first
+    chroma_client = get_chroma_client()
+    chroma_collection = chroma_client.get_or_create_collection("knowledge")
+    vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+    storage_context = StorageContext.from_defaults(vector_store=vector_store)
+
+    # Check if index already has documents
+    if chroma_collection.count() > 0:
+        print(f"Loading existing index with {chroma_collection.count()} vectors...")
+        index = VectorStoreIndex.from_vector_store(
+            vector_store, storage_context=storage_context
+        )
+        print("Index loaded from disk.")
+    else:
+        print("Loading documents from KNOWLEDGE...")
         documents = SimpleDirectoryReader(
             str(KNOWLEDGE_DIR),
             recursive=True,
@@ -138,344 +183,83 @@ def get_or_build_index():
             filename_as_id=True,
         ).load_data()
         print(f"Loaded {len(documents)} documents.")
-    except Exception as e:
-        print(f"Error loading documents: {e}")
-        return None
-    
-    CHROMA_DIR.mkdir(parents=True, exist_ok=True)
-    client = chromadb.PersistentClient(path=str(CHROMA_DIR))
-    chroma_collection = client.get_or_create_collection("knowledge")
-    vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
-    storage_context = StorageContext.from_defaults(vector_store=vector_store)
-    
-    print("Building vector index...")
-    _search_index = VectorStoreIndex.from_documents(
-        documents,
-        storage_context=storage_context,
-        show_progress=True,
+
+        print("Building vector index...")
+        index = VectorStoreIndex.from_documents(
+            documents,
+            storage_context=storage_context,
+            show_progress=True,
+        )
+        print("Index ready and saved to disk.")
+
+    query_engine = index.as_query_engine(similarity_top_k=15)
+    notes_tool = QueryEngineTool(
+        query_engine=query_engine,
+        metadata=ToolMetadata(
+            name="search_notes",
+            description=TOOL_DESCRIPTION,
+        ),
     )
-    print("Index ready and saved to disk.")
-    
-    return _search_index
-
-
-class SearchTool:
-    """Simple search tool that persists its query engine."""
-    
-    def __init__(self, index, top_k: int = 10):
-        self.index = index
-        self.query_engine = None
-        self.top_k = top_k
-        self._lock = asyncio.Lock()
-    
-    async def search(self, query: str) -> List[str]:
-        """Search notes and return relevant text chunks (thread-safe)."""
-        if self.index is None:
-            return []
-        
-        async with self._lock:
-            if self.query_engine is None:
-                self.query_engine = self.index.as_query_engine(similarity_top_k=self.top_k)
-            
-            try:
-                # Run sync query in thread pool to not block async loop
-                loop = asyncio.get_event_loop()
-                response = await loop.run_in_executor(None, self.query_engine.query, query)
-                
-                results = []
-                if hasattr(response, 'source_nodes'):
-                    for node in response.source_nodes:
-                        results.append(node.node.text)
-                return results
-            except Exception as e:
-                print(f"Search error: {e}")
-                return []
-
-
-# === MEMORY ===
-
-async def load_memory():
-    """Load persistent memory from disk with caching."""
-    global _memory_cache
-    
-    if _memory_cache is not None:
-        return _memory_cache
-    
-    if MEMORY_FILE.exists():
-        try:
-            async with _memory_lock:
-                loop = asyncio.get_event_loop()
-                content = await loop.run_in_executor(
-                    None, MEMORY_FILE.read_text, "utf-8"
-                )
-                _memory_cache = json.loads(content)
-            return _memory_cache
-        except Exception:
-            pass
-    
-    _memory_cache = {"sessions": []}
-    return _memory_cache
 
+    agent = ReActAgent(
+        name="brain",
+        tools=[notes_tool],
+        llm=llm,
+        system_prompt=SYSTEM_PROMPT,
+    )
 
-async def save_memory(memory):
-    """Save memory to disk with async safety and atomic writes."""
-    try:
-        async with _memory_lock:
-            loop = asyncio.get_event_loop()
-            content = json.dumps(memory, indent=2, ensure_ascii=False)
-            
-            # Atomic write: write to temp then rename
-            def write_atomic():
-                MEMORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-                temp_file = MEMORY_FILE.with_suffix('.tmp')
-                temp_file.write_text(content, encoding="utf-8")
-                temp_file.replace(MEMORY_FILE)
-            
-            await loop.run_in_executor(None, write_atomic)
-    except Exception as e:
-        print(f"Warning: Could not save memory: {e}")
+    return agent
 
 
-async def record_exchange(memory, user_msg: str, agent_response: str, searches: List[str]):
-    """Record a conversation exchange to persistent memory."""
-    exchange = {
-        "timestamp": datetime.now().isoformat(),
-        "user": user_msg[:MAX_MESSAGE_LENGTH],
-        "agent": agent_response[:MAX_MESSAGE_LENGTH * 2],
-        "searches": searches,
-    }
-    
-    if "sessions" not in memory:
-        memory["sessions"] = []
-    
-    memory["sessions"].append(exchange)
-    
-    # Keep all sessions forever (this is a memory entity, not a tool)
-    await save_memory(memory)
+async def run_with_trace(agent, ctx, message, memory):
+    """
+    Run the agent with full reasoning trace capture.
+    Returns (reasoning_parts, final_response, searches).
+    """
+    # Inject memory context into the message if we have history
+    mem_context = get_memory_context(memory)
+    augmented = message
+    if mem_context:
+        augmented = f"{mem_context}\n\nCurrent query: {message}"
 
+    handler = agent.run(augmented, ctx=ctx)
 
-def get_recent_history(memory, n: int = MAX_HISTORY_TURNS) -> List[Dict]:
-    """Get recent conversation history as structured list."""
-    if not memory.get("sessions"):
-        return []
-    return memory["sessions"][-n:]
-
-
-# === DEEPSEEK API ===
-
-async def call_deepseek_chat(
-    messages: List[Dict[str, str]],
-    api_key: str,
-    temperature: float = 0.7,
-    max_tokens: int = MAX_TOKENS_RESPONSE,
-    retries: int = 3,
-) -> str:
-    """Call DeepSeek API directly with retry logic."""
-    
-    url = "https://api.deepseek.com/v1/chat/completions"
-    
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-    }
-    
-    payload = {
-        "model": "deepseek-chat",
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-    
-    client = get_http_client()
-    last_error = None
-    
-    for attempt in range(retries):
-        try:
-            response = await client.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            data = response.json()
-            return data["choices"][0]["message"]["content"]
-        except httpx.HTTPStatusError as e:
-            last_error = e
-            if e.response.status_code == 429:  # Rate limit
-                wait_time = 2 ** attempt
-                print(f"Rate limited, waiting {wait_time}s...")
-                await asyncio.sleep(wait_time)
-                continue
-            elif e.response.status_code >= 500:
-                await asyncio.sleep(1)
-                continue
-            raise
-        except (httpx.NetworkError, httpx.TimeoutException) as e:
-            last_error = e
-            await asyncio.sleep(1)
-            continue
-    
-    raise last_error or Exception("All retries failed")
-
-
-# === AGENT LOGIC ===
-
-SYSTEM_PROMPT = """You are a direct, analytical conversational partner with a personal knowledge base of notes, transcripts, and conversations.
-
-IMPORTANT: You MUST search your knowledge base proactively. When any topic comes up, IMMEDIATELY search for relevant information. Do NOT ask the user what to search for - just search based on what they're talking about.
-
-To search, your ENTIRE response must be: SEARCH: <query>
-Example: SEARCH: CIA occult programs
-
-Guidelines:
-- ALWAYS search first when a topic is mentioned - your knowledge base is your memory
-- Never say "what would you like me to search for" - just search
-- After getting search results, speak from that knowledge naturally
-- Be direct and have your own perspective"""
-
-
-def truncate_for_tokens(text: str, max_chars: int = 8000) -> str:
-    """Rough truncation to stay within token limits."""
-    if len(text) <= max_chars:
-        return text
-    return text[:max_chars] + "... [truncated]"
-
-
-async def run_agent(
-    search_tool: SearchTool,
-    message: str,
-    memory: Dict,
-    api_key: str,
-) -> Tuple[str, List[str]]:
-    """Run the agent with search capability."""
-    
-    # Validate/truncate input
-    message = message.strip()
-    if len(message) > MAX_MESSAGE_LENGTH:
-        message = message[:MAX_MESSAGE_LENGTH] + "... [truncated]"
-    
-    # Build message history
-    history = get_recent_history(memory, n=MAX_HISTORY_TURNS)
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-    
-    for ex in history:
-        messages.append({
-            "role": "user", 
-            "content": truncate_for_tokens(ex["user"], 2000)
-        })
-        messages.append({
-            "role": "assistant", 
-            "content": truncate_for_tokens(ex["agent"], 4000)
-        })
-    
-    messages.append({"role": "user", "content": message})
-    
-    # First call
+    reasoning_parts = []
     searches = []
-    try:
-        response_text = await call_deepseek_chat(messages, api_key)
-    except Exception as e:
-        return f"Error calling API: {str(e)}", []
-    
-    # Check for search
-    if response_text.strip().upper().startswith("SEARCH:"):
-        search_query = response_text.strip()[7:].strip()
-        if len(search_query) > 200:
-            search_query = search_query[:200]
-        searches.append(search_query)
-        
-        try:
-            search_results = await search_tool.search(search_query)
-        except Exception as e:
-            print(f"Search failed: {e}")
-            search_results = []
-        
-        # Build search context
-        if search_results:
-            search_context = "=== SEARCH RESULTS ===\n\n"
-            for i, result in enumerate(search_results[:MAX_SEARCH_RESULTS], 1):
-                truncated = result[:MAX_RESULT_LENGTH]
-                if len(result) > MAX_RESULT_LENGTH:
-                    truncated += "..."
-                search_context += f"[{i}] {truncated}\n\n"
-        else:
-            search_context = "=== SEARCH RESULTS ===\nNo relevant results found.\n"
-        
-        messages.append({"role": "assistant", "content": response_text})
-        messages.append({"role": "user", "content": search_context})
-        
-        # Second call
-        try:
-            response_text = await call_deepseek_chat(messages, api_key)
-        except Exception as e:
-            response_text = f"Search completed but error: {str(e)}"
-    
-    # Record to memory
-    await record_exchange(memory, message, response_text, searches)
-    
-    return response_text, searches
-
-
-# === INITIALIZATION ===
-
-async def init_async():
-    """Async initialization."""
-    global _search_index, _memory_cache
-    
-    get_api_key()
-    
-    if _memory_cache is None:
-        _memory_cache = await load_memory()
-    
-    if _search_index is None:
-        # Run index loading in thread pool (it's blocking)
-        loop = asyncio.get_event_loop()
-        _search_index = await loop.run_in_executor(None, get_or_build_index)
-    
-    return _search_index, _memory_cache
-
-
-def init():
-    """Sync wrapper for init - use init_async() in async context instead."""
-    global _search_index, _memory_cache
-    
-    get_api_key()
-    
-    if _memory_cache is None:
-        # This is a hack for sync init - should use init_async ideally
-        try:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                # Can't run async in running loop, return empty and let async init fix it
-                _memory_cache = {"sessions": []}
-            else:
-                _memory_cache = loop.run_until_complete(load_memory())
-        except RuntimeError:
-            _memory_cache = {"sessions": []}
-    
-    if _search_index is None:
-        _search_index = get_or_build_index()
-    
-    return _search_index, _memory_cache
-
-
-def reload_memory_sync():
-    """Force reload memory from disk (synchronous version for non-async contexts)."""
-    global _memory_cache
-    _memory_cache = None
-    
-    if MEMORY_FILE.exists():
-        try:
-            _memory_cache = json.loads(MEMORY_FILE.read_text(encoding="utf-8"))
-            return _memory_cache
-        except Exception:
-            pass
-    
-    _memory_cache = {"sessions": []}
-    return _memory_cache
-
-
-async def reload_memory():
-    """Force reload memory from disk (async version)."""
-    global _memory_cache
-    _memory_cache = None
-    return await load_memory()
-
-
-print("Brain module loaded.")
+    final_text = ""
+
+    async for ev in handler.stream_events():
+        if isinstance(ev, AgentStream):
+            final_text += ev.delta
+        elif isinstance(ev, ToolCallResult):
+            searches.append(ev.tool_name)
+            reasoning_parts.append({
+                "type": "tool_call",
+                "tool": ev.tool_name,
+                "result_preview": str(ev.tool_output.content)[:300] if ev.tool_output else "N/A",
+            })
+
+    response = await handler
+    if not final_text:
+        final_text = str(response)
+
+    # Record to persistent memory
+    record_exchange(memory, message, final_text, searches)
+
+    return reasoning_parts, final_text, searches
+
+
+# === STARTUP ===
+
+print("Initializing Proprietary Intelligence System...")
+agent = build_agent()
+memory = load_memory()
+
+if agent:
+    # Persistent context — same Context across all calls = stateful agent
+    agent_ctx = Context(agent)
+    session_count = len(memory.get("sessions", []))
+    print(f"System ready. {session_count} exchanges in persistent memory.")
+else:
+    agent_ctx = None
+    print("System failed to initialize.")

requirements.txt

@@ -1,7 +1,7 @@
 gradio==6.6.0
 huggingface_hub>=0.20.0
 llama-index-core>=0.11.0
+llama-index-llms-openai-like>=0.6.0
 llama-index-embeddings-huggingface>=0.3.0
 llama-index-vector-stores-chroma>=0.4.0
 chromadb>=0.4.0
-httpx>=0.25.0