Refactor: Implement LiteLLM Mixture of Agents Orchestration

.env.example

@@ -5,6 +5,10 @@
 # Get your free key at: https://console.groq.com
 GROQ_API_KEY=gsk_your_key_here
 
+# Cerebras Inference API (free 1M tokens/day)
+# Get your free key at: https://inference.cerebras.ai
+CEREBRAS_API_KEY=cbr_your_key_here
+
 # Razorpay (for premium tier billing)
 RAZORPAY_KEY_ID=rzp_test_...
 RAZORPAY_KEY_SECRET=secret_...

agent/nodes.py

@@ -114,16 +114,11 @@ async def call_model_node(state: dict) -> dict:
         if not isinstance(msg, SystemMessage):
             augmented.append(msg)
 
-    # Get the LLM (Groq — free tier, blazing fast)
+    # Get the LLM from the Mixture of Agents Router (Heavy Pipeline)
     try:
-        from langchain_groq import ChatGroq
-        import os
-
-        llm = ChatGroq(
-            model="llama-3.3-70b-versatile",
-            api_key=os.getenv("GROQ_API_KEY", ""),
-            temperature=0.7,
-        )
+        from chronos_core.llm_router import get_heavy_pipeline
+        
+        llm = get_heavy_pipeline()
 
         # Bind tools so the agent can interact with SaaS connectors
         from agent.tools import CHRONOS_TOOLS

chronos_core/llm_router.py

@@ -0,0 +1,64 @@
+"""
+Chronos OS — Multi-Model Mixture of Agents Router
+===================================================
+Intelligently routes tasks to different LLMs to aggregate free-tier API limits.
+Falls back safely if rate limits (429) or downtimes occur.
+"""
+
+import os
+import logging
+from typing import Any
+
+from langchain_community.chat_models import ChatLiteLLM
+from langchain_core.language_models.chat_models import BaseChatModel
+
+logger = logging.getLogger("chronos.llm_router")
+
+def get_fast_pipeline_kwargs() -> dict[str, Any]:
+    """
+    Routing configuration for the Fast Pipeline (Memory Extraction).
+    Primary: Cerebras Llama 3.1 8B (Massive limit, extreme speed)
+    Fallback: Groq Llama 3.1 8B Instant
+    """
+    has_cerebras = bool(os.getenv("CEREBRAS_API_KEY"))
+    has_groq = bool(os.getenv("GROQ_API_KEY"))
+    
+    if has_cerebras and has_groq:
+        return {
+            "model": "cerebras/llama3.1-8b",
+            "fallbacks": [{"model": "groq/llama-3.1-8b-instant"}]
+        }
+    elif has_cerebras:
+        return {"model": "cerebras/llama3.1-8b"}
+    else:
+        # Default to Groq if no Cerebras key is found
+        return {"model": "groq/llama-3.1-8b-instant"}
+
+
+def get_heavy_pipeline() -> BaseChatModel:
+    """
+    Routing configuration for the Heavy Pipeline (Agentic Reasoning).
+    Primary: Cerebras Qwen 3 235B (Elite logic and deep reasoning)
+    Fallback: Groq Llama 3.3 70B
+    """
+    has_cerebras = bool(os.getenv("CEREBRAS_API_KEY"))
+    has_groq = bool(os.getenv("GROQ_API_KEY"))
+    
+    # Initialize the robust Groq fallback (always available if .env set)
+    # Using litellm via langchain
+    groq_llm = ChatLiteLLM(
+        model="groq/llama-3.3-70b-versatile",
+        temperature=0.4
+    )
+    
+    if has_cerebras:
+        cerebras_llm = ChatLiteLLM(
+            model="cerebras/qwen3-235b",
+            temperature=0.4
+        )
+        if has_groq:
+            # Langchain native fallback mechanism
+            return cerebras_llm.with_fallbacks([groq_llm])
+        return cerebras_llm
+        
+    return groq_llm

chronos_core/svo_parser.py

@@ -128,36 +128,14 @@ class SVOParser:
     """
     Extracts Subject-Verb-Object tuples from raw text.
     
-    Primary: Groq API (free tier — DeepSeek R1 / Llama at 300+ tok/sec)
-    Fallback: Regex patterns (when LLM fails or quota exhausted)
+    Primary: High Speed Model via LiteLLM Router.
+    Fallback: Regex patterns (when LLM fails or limits exhausted)
     """
 
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        model: str = "llama-3.3-70b-versatile",
-    ):
-        self.api_key = api_key or os.getenv("GROQ_API_KEY", "")
-        self.model = model
-        self._client = None
-
-        if self.api_key:
-            try:
-                from groq import Groq
-                self._client = Groq(api_key=self.api_key)
-                logger.info(f"Groq SVO parser initialized with model: {self.model}")
-            except ImportError:
-                logger.warning(
-                    "groq not installed. Using regex fallback. "
-                    "Install with: pip install groq"
-                )
-            except Exception as e:
-                logger.warning(f"Failed to init Groq client: {e}. Using regex fallback.")
-        else:
-            logger.warning(
-                "No GROQ_API_KEY set. SVO parser will use regex fallback only. "
-                "Get a free key at https://console.groq.com"
-            )
+    def __init__(self):
+        from .llm_router import get_fast_pipeline_kwargs
+        self._llm_kwargs = get_fast_pipeline_kwargs()
+        logger.info(f"SVO parser initialized with fast pipeline: {self._llm_kwargs.get('model')}")
 
     async def parse(
         self,
@@ -166,51 +144,52 @@ class SVOParser:
     ) -> list[SVOTuple]:
         """
         Extract SVO tuples from text.
-        Tries Groq (DeepSeek R1) first, falls back to regex.
+        Tries Litellm Fast Pipeline first, falls back to regex.
         """
         if not text or not text.strip():
             return []
 
         ts = timestamp or datetime.utcnow()
 
-        # Try LLM extraction
-        if self._client:
-            try:
-                return await self._parse_with_groq(text, ts)
-            except Exception as e:
-                logger.warning(f"Groq SVO extraction failed: {e}. Falling back to regex.")
+        # Try LLM extraction via LiteLLM
+        try:
+            return await self._parse_with_litellm(text, ts)
+        except Exception as e:
+            logger.warning(f"Fast Pipeline SVO extraction failed: {e}. Falling back to regex.")
 
         # Regex fallback
         return _regex_fallback(text, ts)
 
-    async def _parse_with_groq(
+    async def _parse_with_litellm(
         self,
         text: str,
         timestamp: datetime,
     ) -> list[SVOTuple]:
-        """Call Groq API (DeepSeek R1) to extract SVO tuples."""
-        import asyncio
+        """Call LiteLLM unified completion to extract SVO tuples."""
+        import litellm
+        from .llm_router import get_fast_pipeline_kwargs
 
         prompt = SVO_EXTRACTION_PROMPT.format(
             text=text,
             current_time=timestamp.isoformat(),
         )
 
-        # Groq SDK is synchronous — wrap for async
-        response = await asyncio.to_thread(
-            self._client.chat.completions.create,
-            model=self.model,
-            messages=[
-                {
-                    "role": "system",
-                    "content": "You are a precise JSON event extractor. Output ONLY valid JSON arrays.",
-                },
-                {"role": "user", "content": prompt},
-            ],
-            temperature=0.1,
-            max_tokens=2000,
-            response_format={"type": "json_object"},
-        )
+        kwargs = get_fast_pipeline_kwargs()
+        kwargs["messages"] = [
+            {
+                "role": "system",
+                "content": "You are a precise JSON event extractor. Output ONLY valid JSON arrays.",
+            },
+            {"role": "user", "content": prompt},
+        ]
+        kwargs["temperature"] = 0.1
+        kwargs["max_tokens"] = 2000
+        # Not all fallback models gracefully support strict json format enforcement in litellm uniformly if the provider doesn't support it.
+        # But we will use it for safety.
+        kwargs["response_format"] = {"type": "json_object"}
+
+        # LiteLLM acompletion directly leverages the fallback arrays natively!
+        response = await litellm.acompletion(**kwargs)
 
         raw = response.choices[0].message.content.strip()
 

dashboard/app.py

@@ -560,7 +560,7 @@ if page == "⟡ Overview":
         with col4:
             st.markdown("""
             <div class="metric-card">
-                <div class="metric-value" style="font-size:1.8rem">Llama 3.3 70B</div>
+                <div class="metric-value" style="font-size:1.4rem; padding-top: 0.3rem;">Qwen 3 + Llama Mixture</div>
                 <div class="metric-label">AI Engine</div>
             </div>
             """, unsafe_allow_html=True)
@@ -613,7 +613,7 @@ elif page == "⭳ Ingest Events":
         label_visibility="collapsed",
     )
 
-    parse_svo = st.checkbox("✧ Enable AI SVO Parsing (Llama 3.3 70B)", value=True)
+    parse_svo = st.checkbox("✧ Enable Fast SVO Parsing (Llama Mixture)", value=True)
 
     if st.button("⭳ Ingest Into Memory") and stored_key and events_text.strip():
         lines = [l.strip() for l in events_text.strip().split("\n") if l.strip()]
@@ -623,7 +623,7 @@ elif page == "⭳ Ingest Events":
             "parse_svo": parse_svo,
         }
 
-        with st.spinner("Llama 3.3 70B is extracting temporal events..."):
+        with st.spinner("Llama Engine is extracting temporal events..."):
             result = api_call("POST", "/ingest", stored_key, json=payload)
 
         if "error" not in result:

requirements.txt

@@ -13,3 +13,4 @@ razorpay>=1.4.0
 python-dotenv>=1.0.0
 httpx>=0.28.0
 sentence-transformers>=3.0.0
+langchain-community>=0.3.0

scratch_remove.py

@@ -0,0 +1,35 @@
+import re
+
+def remove_emojis():
+    filepath = "dashboard/app.py"
+    with open(filepath, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Define exact replacements
+    replacements = {
+        "🔑": "⚷",
+        "📥": "⭳",
+        "🔍": "⚲",
+        "🤖": "✦",
+        "🔗": "⚙",
+        "📊": "▤",
+        "✅": "✓",
+        "⚠️": "⚠",
+        "✨": "✧",
+        "🕰️": "⧗",
+        "🏠": "⌂"
+    }
+
+    for emoji, symbol in replacements.items():
+        content = content.replace(emoji, symbol)
+
+    # Some old ones might still have the space, or might need removal.
+    # The symbols above are very elegant, but if the user wants them completely gone:
+    # "remove evry possible emoji... replace them with something better and adjust that name also"
+    
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(content)
+
+if __name__ == "__main__":
+    remove_emojis()
+    print("Emojis replaced successfully.")