uchi-python 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

uchi/__init__.py

@@ -16,6 +16,8 @@ TabularPredictor / TabularRegressor / TimeSeriesClassifier all support
 partial_fit() for online / incremental learning.
 """
 
+__version__ = "0.2.0"
+
 from .predictor  import UniversalPredictor
 from .forest     import PredictorForest
 from .discretize import FeatureDiscretizer, LabelEncoder
@@ -28,8 +30,14 @@ from .long_term_store   import LongTermStore
 from .dual_predictor    import DualPredictor
 from .online_tokenizer  import OnlineTokenizer
 from .node_compressor   import NodeCompressor
+from .process           import ProcessPredictor, OntologicalState, OntologicalAction
+from .simulation_engine import LifelongSimulationEngine
+
+from .memory            import AssociativeMemory
+from .omni_router       import OmniRouter
+from .omni_tokenizer    import OmniTokenizer
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     # Core engine
@@ -54,4 +62,12 @@ __all__ = [
     "DualPredictor",
     "OnlineTokenizer",
     "NodeCompressor",
+    "ProcessPredictor",
+    "OntologicalState",
+    "OntologicalAction",
+    "LifelongSimulationEngine",
+
+    "AssociativeMemory",
+    "OmniRouter",
+    "OmniTokenizer"
 ]

uchi/api.py

@@ -0,0 +1,86 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from .omni_router import OmniRouter
+import os
+import pickle
+
+ASCII_LOGO = r"""
+      |\_/\_/\_/|
+      |         |
+      |  O   O  |
+      |    ^    |
+       \  ___  /
+        \_____/
+ODUSP Daemon v0.2.0
+"""
+
+app = FastAPI(title="ODUSP Brain API")
+
+# Mount UI Harness static files
+STATIC_DIR = os.path.join(os.path.dirname(__file__), "static")
+if os.path.exists(STATIC_DIR):
+    app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+@app.get("/")
+async def serve_ui():
+    if os.path.exists(os.path.join(STATIC_DIR, "index.html")):
+        return FileResponse(os.path.join(STATIC_DIR, "index.html"))
+    return {"message": "ODUSP API is running, but UI is missing."}
+@app.get("/style.css")
+async def serve_css():
+    return FileResponse(os.path.join(STATIC_DIR, "style.css"))
+@app.get("/app.js")
+async def serve_js():
+    return FileResponse(os.path.join(STATIC_DIR, "app.js"))
+
+router = None
+
+class StreamRequest(BaseModel):
+    tokens: list[str]
+
+class QueryRequest(BaseModel):
+    tokens: list[str]
+
+class PredictRequest(BaseModel):
+    context: list[str] = []
+    steps: int = 5
+    temperature: float = 0.0
+    creativity: float = 0.0
+
+def load_brain(path: str = "brain.uchi") -> OmniRouter:
+    if os.path.exists(path):
+        try:
+            with open(path, "rb") as f:
+                return pickle.load(f)
+        except Exception as e:
+            print(f"[-] Failed to load {path}: {e}")
+            # Fall back to new router if file is corrupted
+            pass
+    return OmniRouter(use_bpe=True, memory_window=5)
+
+@app.on_event("startup")
+async def startup_event():
+    global router
+    print(ASCII_LOGO)
+    print("[*] Booting ODUSP daemon...")
+    router = load_brain()
+    print("[+] Brain loaded and active.")
+
+@app.post("/stream")
+async def stream_data(req: StreamRequest):
+    if not req.tokens:
+        raise HTTPException(status_code=400, detail="Empty token list")
+    router.stream(req.tokens)
+    return {"status": "success", "processed": len(req.tokens)}
+
+@app.post("/query")
+async def query_memory(req: QueryRequest):
+    ans = router.query(req.tokens)
+    return {"answer": ans}
+
+@app.post("/predict")
+async def predict_future(req: PredictRequest):
+    pred = router.predict_future(req.context, steps=req.steps, temperature=req.temperature, creativity=req.creativity)
+    return {"prediction": pred}

uchi/api_server.py

@@ -0,0 +1,195 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from uchi.omni_router import OmniRouter
+from uchi.cli import load_brain, save_brain
+import logging
+
+_router = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global _router
+    _router = load_brain()
+    if _router is None:
+        _router = OmniRouter(use_bpe=False, memory_window=5)
+        save_brain(_router)
+    # Start background RL daemon and any other background jobs
+    _router.start_background_jobs()
+    yield
+    # Persist on shutdown
+    if _router is not None:
+        _router.stop_background_jobs()
+        save_brain(_router)
+
+
+app = FastAPI(
+    title="Uchi ODUSP API",
+    description="Deterministic Universal Sequence Predictor — programmatic interface.",
+    lifespan=lifespan,
+)
+
+
+class ChatRequest(BaseModel):
+    message: str
+
+
+class ChatResponse(BaseModel):
+    reply: str
+    entropy: float = 0.0
+
+
+class SkillResponse(BaseModel):
+    reply: str
+    skill: str
+
+
+class BootstrapRequest(BaseModel):
+    text: str | None = None
+    url: str | None = None
+
+
+class BootstrapResponse(BaseModel):
+    tokens_ingested: int
+    source: str
+
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    """
+    Send a message to the OmniRouter.
+
+    Messages starting with `/name args` are dispatched to the skill registry.
+    All other messages go through the standard chat pipeline.
+    """
+    if not request.message.strip():
+        raise HTTPException(status_code=400, detail="Message cannot be empty")
+
+    try:
+        msg = request.message.strip()
+        if msg.startswith("/"):
+            parts = msg[1:].split(None, 1)
+            name = parts[0]
+            args = parts[1] if len(parts) > 1 else ""
+            reply = _router.skills.dispatch(name, args)
+        else:
+            reply = _router.chat(msg)
+
+        save_brain(_router)
+        return ChatResponse(reply=reply)
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        logging.error(f"API Error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/skill/{name}", response_model=SkillResponse)
+async def skill_endpoint(name: str, request: ChatRequest):
+    """Invoke a named skill directly."""
+    if not _router.skills.has(name):
+        raise HTTPException(status_code=404, detail=f"Skill '{name}' not found")
+    reply = _router.skills.dispatch(name, request.message)
+    save_brain(_router)
+    return SkillResponse(reply=reply, skill=name)
+
+
+@app.get("/skills")
+async def list_skills():
+    """List all registered skills (built-in + user-installed)."""
+    return {
+        "skills": [
+            {
+                "name": s.name,
+                "description": s.description,
+                "args": s.args_hint,
+                "mode": s.mode,
+                "source": s.source_path,
+            }
+            for s in _router.skills.list_skills()
+        ]
+    }
+
+
+@app.get("/metrics")
+async def metrics_endpoint():
+    memory_records = (
+        len(_router.memory.cpu_mem.records)
+        if hasattr(_router.memory, "cpu_mem")
+        else 0
+    )
+    return {
+        "status": "online",
+        "memory_records": memory_records,
+        "ssm_baseline_mean": round(_router.baseline.mean, 4),
+        "skills_loaded": len(_router.skills.list_skills()),
+        "mode": "deterministic",
+    }
+
+
+@app.get("/telemetry")
+async def telemetry_endpoint():
+    """
+    Exposes deep internal engine telemetry for the TUI and Cognitive Debugger.
+    Pulls data from the central telemetry singleton if available.
+    """
+    try:
+        import uchi.telemetry as _tel
+        return _tel.dump_all()
+    except Exception as e:
+        return {"error": f"Telemetry not available: {e}"}
+
+
+@app.post("/bootstrap", response_model=BootstrapResponse)
+async def bootstrap_endpoint(request: BootstrapRequest):
+    """
+    Ingest raw text or a URL into Uchi's trie and AssociativeMemory.
+
+    Accepts JSON body with one of:
+      - `{"text": "raw text to learn"}` — streams the text directly
+      - `{"url": "https://..."}` — fetches the page, strips HTML, then streams
+
+    Once Uchi has tool-routing, it can call this endpoint autonomously to
+    permanently memorise content it discovers via web search.
+    """
+    if not request.text and not request.url:
+        raise HTTPException(status_code=400, detail="Provide either 'text' or 'url'.")
+
+    raw_text = request.text or ""
+    source = "text"
+
+    if request.url:
+        source = request.url
+        try:
+            import requests as _req
+            from bs4 import BeautifulSoup
+            resp = _req.get(request.url, timeout=10, headers={"User-Agent": "Uchi/1.0"})
+            resp.raise_for_status()
+            soup = BeautifulSoup(resp.text, "html.parser")
+            for tag in soup(["script", "style", "nav", "footer", "header"]):
+                tag.decompose()
+            raw_text = soup.get_text(separator=" ", strip=True)
+        except Exception as exc:
+            raise HTTPException(status_code=502, detail=f"Failed to fetch URL: {exc}")
+
+    if not raw_text.strip():
+        raise HTTPException(status_code=400, detail="No usable text found.")
+
+    tokens = _router.tokenizer.tokenize(raw_text.split(), is_inference=False)
+    _router.stream(tokens)
+    save_brain(_router)
+    return BootstrapResponse(tokens_ingested=len(tokens), source=source)
+
+
+@app.get("/debug/walk")
+async def debug_walk_endpoint():
+    if not hasattr(_router, "last_walk_data"):
+        return {"error": "No walk data available"}
+    return _router.last_walk_data
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

uchi/builder.py

@@ -0,0 +1,214 @@
+import os
+import glob
+import logging
+from tqdm import tqdm
+from uchi.cli import save_brain
+from uchi.omni_router import OmniRouter
+from uchi.neuro_symbolic import get_ssm
+import torch
+
+# A universal limit for dataset slicing so we don't spend 24 hours downloading 
+# 1 million rows, while still pulling a massive functional knowledge base.
+KNOWLEDGE_LIMIT = 50
+
+def _safe_load_dataset(*args, **kwargs):
+    from datasets import load_dataset
+    try:
+        if len(args) == 2 and not kwargs:
+            return load_dataset(args[0], split=args[1])
+        return load_dataset(*args, **kwargs)
+    except Exception as e:
+        logging.warning(f"[-] Failed to load {args[0] if args else kwargs.get('path', 'dataset')}: {e}")
+        return None
+
+def build_full_brain(brain_path="brain.uchi"):
+    """
+    The Universal Master Builder.
+    Executes the 5-stage reconstruction pipeline to build the brain from scratch.
+    """
+    print("\n[bold #bb9af7]=== UCHI UNIVERSAL BRAIN BUILDER ===[/bold #bb9af7]")
+    print("[*] No existing brain detected. Initiating 5-Stage Reconstruction Pipeline.\n")
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # Phase 1: The Wipe
+    # ──────────────────────────────────────────────────────────────────────────
+    print("[bold #7dcfff][*] Phase 1/5: Wiping corrupted or outdated states...[/bold #7dcfff]")
+    project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    
+    patterns = ["brain*.uchi", "*.pt", "*.db", "uchi_cpu_memory*.json", "uchi_cpu_memory*.npy"]
+    for pat in patterns:
+        for f in glob.glob(os.path.join(project_root, pat)):
+            os.remove(f)
+            print(f"  [-] Deleted {os.path.basename(f)}")
+
+    print("  [+] Clean slate achieved.")
+    router = OmniRouter(use_bpe=False)
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # Phase 2: SSM Neural Pre-training
+    # ──────────────────────────────────────────────────────────────────────────
+    print("\n[bold #7dcfff][*] Phase 2/5: SSM Neural Pre-training (databricks-dolly-15k)...[/bold #7dcfff]")
+    ds_dolly = _safe_load_dataset("databricks/databricks-dolly-15k", f"train[:{KNOWLEDGE_LIMIT}]")
+    if ds_dolly:
+        ssm = get_ssm()
+        optimizer = torch.optim.Adam(ssm.parameters(), lr=1e-3)
+        for item in tqdm(ds_dolly, desc="Pre-training MoE Weights"):
+            user_turn = item.get("instruction", "").strip()
+            assistant_turn = item.get("response", "").strip()
+            if not user_turn or not assistant_turn:
+                continue
+            
+            tokens = ["<|user|>"] + router.tokenizer.tokenize(user_turn.split(), is_inference=False) + \
+                     ["<|assistant|>"] + router.tokenizer.tokenize(assistant_turn.split(), is_inference=False) + ["<|end|>"]
+            
+            router.stream(tokens)
+            optimizer.zero_grad()
+            v_loss = ssm.update_value(tokens, reward=1.0)
+            d_loss = ssm.train_dynamics(tokens)
+            (v_loss + d_loss).backward()
+            optimizer.step()
+        torch.save(ssm.state_dict(), os.path.join(project_root, "ssm_dynamics.pt"))
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # Phase 3: Massive World Knowledge Ingestion
+    # ──────────────────────────────────────────────────────────────────────────
+    print("\n[bold #7dcfff][*] Phase 3/5: Massive World Knowledge Ingestion...[/bold #7dcfff]")
+    
+    # 3A: OpenHermes (Conversational)
+    ds_hermes = _safe_load_dataset("teknium/OpenHermes-2.5", f"train[:{KNOWLEDGE_LIMIT}]")
+    if ds_hermes:
+        for item in tqdm(ds_hermes, desc="Ingesting OpenHermes (Chat)"):
+            conversations = item.get("conversations", [])
+            text = ""
+            for turn in conversations:
+                role = "<|user|>" if turn.get("from") == "human" else "<|assistant|>"
+                text += f"{role} {turn.get('value', '')} "
+            if text:
+                router.stream(router.tokenizer.tokenize((text + "<|end|>").split(), is_inference=False))
+
+    # 3B: Wikipedia (Encyclopedic)
+    ds_wiki = _safe_load_dataset("wikipedia", "20220301.en", split=f"train[:{KNOWLEDGE_LIMIT}]")
+    if not ds_wiki:
+        # Fallback dataset format if config needed
+        ds_wiki = _safe_load_dataset("wikipedia", "20220301.en[train]") 
+    if ds_wiki:
+        for item in tqdm(ds_wiki, desc="Ingesting Wikipedia (Facts)"):
+            text = f"<|user|> Tell me about {item.get('title', '')}. <|assistant|> {item.get('text', '')[:1000]} <|end|>"
+            router.stream(router.tokenizer.tokenize(text.split(), is_inference=False))
+
+    # 3C: MMLU (Graduate Reasoning)
+    ds_mmlu = _safe_load_dataset("cais/mmlu", "all") # We'll just take the test split
+    if not ds_mmlu:
+        from datasets import load_dataset
+        try:
+            ds_mmlu = load_dataset("cais/mmlu", "all", split="test")
+        except Exception:
+            ds_mmlu = None
+    if ds_mmlu:
+        # Convert to list and slice to enforce KNOWLEDGE_LIMIT since split="test" returns the whole split
+        ds_mmlu_subset = list(ds_mmlu)[:KNOWLEDGE_LIMIT]
+        for item in tqdm(ds_mmlu_subset, desc="Ingesting MMLU (Reasoning)"):
+            q, choices, ans_idx = item.get('question',''), item.get('choices',[]), item.get('answer',-1)
+            if 0 <= ans_idx < len(choices):
+                ans = choices[ans_idx]
+                text = f"<|user|> Question: {q} Choices: {', '.join(choices)} <|assistant|> {ans} <|end|>"
+                router.stream(router.tokenizer.tokenize(text.split(), is_inference=False))
+
+    # 3D: GSM8K (Math Reasoning)
+    ds_gsm8k = _safe_load_dataset("gsm8k", "main")
+    if not ds_gsm8k:
+        from datasets import load_dataset
+        try:
+            ds_gsm8k = load_dataset("gsm8k", "main", split="test")
+        except Exception:
+            ds_gsm8k = None
+    if ds_gsm8k:
+        ds_gsm8k_subset = list(ds_gsm8k)[:KNOWLEDGE_LIMIT]
+        for item in tqdm(ds_gsm8k_subset, desc="Ingesting GSM8K (Math)"):
+            text = f"<|user|> {item.get('question','')} <|assistant|> {item.get('answer','')} <|end|>"
+            router.stream(router.tokenizer.tokenize(text.split(), is_inference=False))
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # Phase 4: Rigorous Code Logic
+    # ──────────────────────────────────────────────────────────────────────────
+    print("\n[bold #7dcfff][*] Phase 4/5: Rigorous Code Logic Ingestion...[/bold #7dcfff]")
+    
+    # 4A: SWE-Bench (GitHub Issues)
+    ds_swe = _safe_load_dataset("princeton-nlp/SWE-bench", "test")
+    if not ds_swe:
+        from datasets import load_dataset
+        try:
+            ds_swe = load_dataset("princeton-nlp/SWE-bench", split="test")
+        except Exception:
+            ds_swe = None
+    if ds_swe:
+        ds_swe_subset = list(ds_swe)[:KNOWLEDGE_LIMIT]
+        for item in tqdm(ds_swe_subset, desc="Ingesting SWE-Bench (Engineering)"):
+            issue, patch = item.get('problem_statement',''), item.get('patch','')
+            text = f"<|user|> Fix issue:\n{issue[:500]} <|assistant|> {patch[:500]} <|end|>"
+            router.stream(router.tokenizer.tokenize(text.split(), is_inference=False))
+
+    # 4B: HumanEval (Algorithms)
+    ds_humaneval = _safe_load_dataset("openai/openai_humaneval", "test")
+    if ds_humaneval:
+        ds_humaneval_subset = list(ds_humaneval)[:KNOWLEDGE_LIMIT]
+        for item in tqdm(ds_humaneval_subset, desc="Ingesting HumanEval (Algorithms)"):
+            text = f"<|user|> Complete Python code:\n{item.get('prompt','')} <|assistant|> {item.get('canonical_solution','')} <|end|>"
+            router.stream(router.tokenizer.tokenize(text.split(), is_inference=False))
+
+    # Save the master router
+    save_brain(router, os.path.join(project_root, brain_path))
+    
+    # ──────────────────────────────────────────────────────────────────────────
+    # Phase 5: MoE Specialists
+    # ──────────────────────────────────────────────────────────────────────────
+    print("\n[bold #7dcfff][*] Phase 5/5: Building MoE Specialist Sub-Brains...[/bold #7dcfff]")
+    _build_specialists(project_root)
+
+    print("\n[bold #9ece6a][+] RECONSTRUCTION COMPLETE. Uchi is Online.[/bold #9ece6a]")
+    return router
+
+def _build_specialists(project_root):
+    from uchi.omni_router import OmniRouter
+    from uchi.cli import save_brain
+
+    # Brain Code — trained on HumanEval function completions
+    print("  [*] Building brain_code.uchi...")
+    r_code = OmniRouter(use_bpe=False)
+    ds_he = _safe_load_dataset("openai/openai_humaneval", "test")
+    if ds_he:
+        for item in tqdm(list(ds_he)[:KNOWLEDGE_LIMIT], desc="  brain_code ← HumanEval"):
+            text = (f"<|user|> Complete Python code:\n{item['prompt']} "
+                    f"<|assistant|> {item['canonical_solution']} <|end|>")
+            r_code.stream(r_code.tokenizer.tokenize(text.split(), is_inference=False))
+    else:
+        r_code.stream(["<|user|>", "complete", "python", "code", "<|assistant|>", "def", "f", "return", "<|end|>"])
+    save_brain(r_code, os.path.join(project_root, "brain_code.uchi"))
+
+    # Brain Math — trained on GSM8K
+    print("  [*] Building brain_math.uchi...")
+    r_math = OmniRouter(use_bpe=False)
+    ds_math = _safe_load_dataset("gsm8k", "main")
+    if ds_math:
+        for item in tqdm(list(ds_math)[:KNOWLEDGE_LIMIT], desc="  brain_math ← GSM8K"):
+            text = f"<|user|> {item['question']} <|assistant|> {item['answer']} <|end|>"
+            r_math.stream(r_math.tokenizer.tokenize(text.split(), is_inference=False))
+    else:
+        r_math.stream(["<|user|>", "math", "equation", "<|assistant|>", "1", "+", "1", "=", "2", "<|end|>"])
+    save_brain(r_math, os.path.join(project_root, "brain_math.uchi"))
+
+    # Brain Convo — trained on OpenHermes conversational turns
+    print("  [*] Building brain_convo.uchi...")
+    r_convo = OmniRouter(use_bpe=False)
+    ds_convo = _safe_load_dataset("teknium/OpenHermes-2.5", f"train[:{KNOWLEDGE_LIMIT}]")
+    if ds_convo:
+        for item in tqdm(ds_convo, desc="  brain_convo ← OpenHermes"):
+            text = ""
+            for turn in item.get("conversations", []):
+                role = "<|user|>" if turn.get("from") == "human" else "<|assistant|>"
+                text += f"{role} {turn.get('value', '')} "
+            if text:
+                r_convo.stream(r_convo.tokenizer.tokenize((text + "<|end|>").split(), is_inference=False))
+    else:
+        r_convo.stream(["<|user|>", "hello", "<|assistant|>", "hi", "how", "are", "you", "<|end|>"])
+    save_brain(r_convo, os.path.join(project_root, "brain_convo.uchi"))