multimind 0.1.0__tar.gz

multimind-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: multimind
+Version: 0.1.0
+Summary: Local-first reasoning pipeline wrapper for Ollama and LM Studio
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: bleach<7.0.0,>=6.2.0
+Requires-Dist: fastapi<1.0.0,>=0.116.0
+Requires-Dist: httpx<1.0.0,>=0.28.0
+Requires-Dist: markdown<4.0.0,>=3.8.0
+Requires-Dist: uvicorn<1.0.0,>=0.35.0
+
+<div align="center">
+  <h1>🧠 MultiMind AI</h1>
+  <p>
+    <b>A local-first web UI that adds a reasoning pipeline on top of small local models.</b>
+  </p>
+  
+  [![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+  [![Local First](https://img.shields.io/badge/Local-First-success.svg)](https://github.com/features)
+  [![Ollama Supported](https://img.shields.io/badge/Ollama-Supported-purple.svg)](https://ollama.com/)
+  [![LM Studio Supported](https://img.shields.io/badge/LM_Studio-Supported-ff69b4.svg)](https://lmstudio.ai/)
+</div>
+
+<br/>
+
+MultiMind AI acts as an intelligent reasoning pipeline for your local AI models. It effortlessly auto-discovers endpoints like Ollama and LM Studio (OpenAI-compatible) and lets you orchestrate dedicated models for different logical phases: **Planning**, **Execution**, and **Critique**.
+
+---
+
+## ✨ Features
+
+- **🧠 Adaptive Reasoning Modes**: Toggle between _Off_, _Medium_, and _Hard_ modes to dictate the depth of the model's reflection.
+- **🔌 Zero-Config Auto-Discovery**:
+  - Automatically hooks into local **Ollama** endpoints (`http://127.0.0.1:11434`).
+  - Supports optional discovery for **LM Studio** (`http://127.0.0.1:1234`).
+- **🎯 Precision Model Mapping**: Assign distinct models to handle the different stages of thought (`plan`, `execute`, and `critique`).
+- **💬 Immersive UI**: Enjoy a streaming timeline interface with collapsible "thought blocks" to keep your UI clean while the AI thinks.
+- **📝 Native Markdown & Math Support**:
+  - Final outputs are beautifully rendered as HTML in the chat view.
+  - Inline and block math equations are flawlessly typeset using a bundled local **KaTeX** build.
+- **⚡ Frictionless Setup**: Purely in-memory settings. Zero `.env` setup required for your first run.
+
+## 🚀 Quick Start
+
+Get up and running in your local environment in seconds:
+
+```bash
+# 1. Create a virtual environment
+python3 -m venv .venv
+
+# 2. Activate the virtual environment
+# On macOS / Linux:
+source .venv/bin/activate
+
+# On Windows:
+.venv\Scripts\activate
+
+# 3. Install the package
+pip install -e .
+
+# 4. Launch the application
+multimind AI
+```
+
+> **Next:** Open your browser and navigate to [http://127.0.0.1:8000](http://127.0.0.1:8000) 🎉
+
+## 🔌 Supported Backends
+
+MultiMind AI works seamlessly with standard local APIs:
+
+- **Ollama**: Connects via `/api/chat` and `/api/tags`
+- **OpenAI-Compatible Servers (e.g., LM Studio)**: Connects via `/v1/chat/completions` and `/v1/models`
+
+_If no provider is automatically detected, you can easily point the backend to your local OpenAI-compatible endpoint using the application's settings panel._
+
+## 💡 How It Works
+
+MultiMind AI splits inference into modular steps, elevating the capabilities of standard models:
+
+1. **Plan**: Formulates a structured approach to the prompt.
+2. **Execute**: Generates the primary response.
+3. **Critique (Hard Mode)**: Evaluates the execution pass as a rough draft and streams refined, critiqued output as the final answer.
+
+> 📝 **Note:** Chat history is intentionally in-memory only for the current MVP.

multimind-0.1.0/README.md

@@ -0,0 +1,73 @@
+<div align="center">
+  <h1>🧠 MultiMind AI</h1>
+  <p>
+    <b>A local-first web UI that adds a reasoning pipeline on top of small local models.</b>
+  </p>
+  
+  [![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+  [![Local First](https://img.shields.io/badge/Local-First-success.svg)](https://github.com/features)
+  [![Ollama Supported](https://img.shields.io/badge/Ollama-Supported-purple.svg)](https://ollama.com/)
+  [![LM Studio Supported](https://img.shields.io/badge/LM_Studio-Supported-ff69b4.svg)](https://lmstudio.ai/)
+</div>
+
+<br/>
+
+MultiMind AI acts as an intelligent reasoning pipeline for your local AI models. It effortlessly auto-discovers endpoints like Ollama and LM Studio (OpenAI-compatible) and lets you orchestrate dedicated models for different logical phases: **Planning**, **Execution**, and **Critique**.
+
+---
+
+## ✨ Features
+
+- **🧠 Adaptive Reasoning Modes**: Toggle between _Off_, _Medium_, and _Hard_ modes to dictate the depth of the model's reflection.
+- **🔌 Zero-Config Auto-Discovery**:
+  - Automatically hooks into local **Ollama** endpoints (`http://127.0.0.1:11434`).
+  - Supports optional discovery for **LM Studio** (`http://127.0.0.1:1234`).
+- **🎯 Precision Model Mapping**: Assign distinct models to handle the different stages of thought (`plan`, `execute`, and `critique`).
+- **💬 Immersive UI**: Enjoy a streaming timeline interface with collapsible "thought blocks" to keep your UI clean while the AI thinks.
+- **📝 Native Markdown & Math Support**:
+  - Final outputs are beautifully rendered as HTML in the chat view.
+  - Inline and block math equations are flawlessly typeset using a bundled local **KaTeX** build.
+- **⚡ Frictionless Setup**: Purely in-memory settings. Zero `.env` setup required for your first run.
+
+## 🚀 Quick Start
+
+Get up and running in your local environment in seconds:
+
+```bash
+# 1. Create a virtual environment
+python3 -m venv .venv
+
+# 2. Activate the virtual environment
+# On macOS / Linux:
+source .venv/bin/activate
+
+# On Windows:
+.venv\Scripts\activate
+
+# 3. Install the package
+pip install -e .
+
+# 4. Launch the application
+multimind AI
+```
+
+> **Next:** Open your browser and navigate to [http://127.0.0.1:8000](http://127.0.0.1:8000) 🎉
+
+## 🔌 Supported Backends
+
+MultiMind AI works seamlessly with standard local APIs:
+
+- **Ollama**: Connects via `/api/chat` and `/api/tags`
+- **OpenAI-Compatible Servers (e.g., LM Studio)**: Connects via `/v1/chat/completions` and `/v1/models`
+
+_If no provider is automatically detected, you can easily point the backend to your local OpenAI-compatible endpoint using the application's settings panel._
+
+## 💡 How It Works
+
+MultiMind AI splits inference into modular steps, elevating the capabilities of standard models:
+
+1. **Plan**: Formulates a structured approach to the prompt.
+2. **Execute**: Generates the primary response.
+3. **Critique (Hard Mode)**: Evaluates the execution pass as a rough draft and streams refined, critiqued output as the final answer.
+
+> 📝 **Note:** Chat history is intentionally in-memory only for the current MVP.

multimind-0.1.0/multimind/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

multimind-0.1.0/multimind/__main__.py

@@ -0,0 +1,5 @@
+from thinking_wrapper.main import run
+
+
+if __name__ == "__main__":
+    run()

multimind-0.1.0/multimind/config.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+APP_NAME = "Thinking-Wrapper"
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 8000
+REQUEST_TIMEOUT_SECONDS = 90.0
+DISCOVERY_TIMEOUT_SECONDS = 1.2
+
+BASE_DIR = Path(__file__).resolve().parent
+STATIC_DIR = BASE_DIR / "static"
+TEMPLATE_DIR = BASE_DIR / "templates"
+PIPELINE_STEPS = ("plan", "execute", "critique")
+
+
+@dataclass(frozen=True)
+class ProviderCandidate:
+    name: str
+    kind: str
+    base_url: str
+
+
+DISCOVERY_CANDIDATES = (
+    ProviderCandidate(
+        name="Ollama",
+        kind="ollama",
+        base_url="http://127.0.0.1:11434",
+    ),
+    ProviderCandidate(
+        name="LM Studio",
+        kind="openai",
+        base_url="http://127.0.0.1:1234",
+    ),
+)

multimind-0.1.0/multimind/discovery.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+import httpx
+
+from thinking_wrapper.config import DISCOVERY_CANDIDATES, DISCOVERY_TIMEOUT_SECONDS, ProviderCandidate
+
+
+@dataclass
+class ProviderInfo:
+    name: str
+    kind: str
+    base_url: str
+    available: bool
+    models: list[str]
+    error: str | None = None
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def normalize_base_url(base_url: str) -> str:
+    return base_url.rstrip("/")
+
+
+async def discover_providers() -> list[ProviderInfo]:
+    providers: list[ProviderInfo] = []
+    async with httpx.AsyncClient(timeout=DISCOVERY_TIMEOUT_SECONDS) as client:
+        for candidate in DISCOVERY_CANDIDATES:
+            providers.append(await probe_provider(client, candidate))
+    return providers
+
+
+async def probe_provider(client: httpx.AsyncClient, candidate: ProviderCandidate) -> ProviderInfo:
+    base_url = normalize_base_url(candidate.base_url)
+
+    try:
+        if candidate.kind == "ollama":
+            response = await client.get(f"{base_url}/api/tags")
+            response.raise_for_status()
+            payload = response.json()
+            models = [item.get("model") or item.get("name") for item in payload.get("models", [])]
+        else:
+            response = await client.get(f"{base_url}/v1/models")
+            response.raise_for_status()
+            payload = response.json()
+            models = [item.get("id") for item in payload.get("data", [])]
+
+        clean_models = [model for model in models if model]
+        return ProviderInfo(
+            name=candidate.name,
+            kind=candidate.kind,
+            base_url=base_url,
+            available=True,
+            models=clean_models,
+        )
+    except Exception as exc:
+        return ProviderInfo(
+            name=candidate.name,
+            kind=candidate.kind,
+            base_url=base_url,
+            available=False,
+            models=[],
+            error=str(exc),
+        )
+
+
+def select_default_provider(providers: list[ProviderInfo]) -> ProviderInfo | None:
+    for provider in providers:
+        if provider.available and provider.models:
+            return provider
+    for provider in providers:
+        if provider.available:
+            return provider
+    return None

multimind-0.1.0/multimind/llm_client.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+
+import httpx
+
+from thinking_wrapper.config import REQUEST_TIMEOUT_SECONDS
+from thinking_wrapper.discovery import normalize_base_url
+
+
+class LocalLLMClient:
+    def __init__(self) -> None:
+        self._client = httpx.AsyncClient(timeout=REQUEST_TIMEOUT_SECONDS)
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def stream_chat(
+        self,
+        *,
+        provider_kind: str,
+        base_url: str,
+        model: str,
+        messages: list[dict[str, str]],
+        temperature: float = 0.2,
+    ) -> AsyncIterator[str]:
+        if provider_kind == "ollama":
+            async for token in self._stream_ollama(
+                base_url=base_url,
+                model=model,
+                messages=messages,
+                temperature=temperature,
+            ):
+                yield token
+            return
+
+        async for token in self._stream_openai(
+            base_url=base_url,
+            model=model,
+            messages=messages,
+            temperature=temperature,
+        ):
+            yield token
+
+    async def _stream_ollama(
+        self,
+        *,
+        base_url: str,
+        model: str,
+        messages: list[dict[str, str]],
+        temperature: float,
+    ) -> AsyncIterator[str]:
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+            "options": {"temperature": temperature},
+        }
+
+        async with self._client.stream(
+            "POST",
+            f"{normalize_base_url(base_url)}/api/chat",
+            json=payload,
+        ) as response:
+            response.raise_for_status()
+            async for line in response.aiter_lines():
+                if not line:
+                    continue
+
+                payload = json.loads(line)
+                message = payload.get("message") or {}
+                content = message.get("content")
+                if content:
+                    yield content
+                if payload.get("done"):
+                    break
+
+    async def _stream_openai(
+        self,
+        *,
+        base_url: str,
+        model: str,
+        messages: list[dict[str, str]],
+        temperature: float,
+    ) -> AsyncIterator[str]:
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+        }
+
+        async with self._client.stream(
+            "POST",
+            f"{normalize_base_url(base_url)}/v1/chat/completions",
+            json=payload,
+        ) as response:
+            response.raise_for_status()
+            async for line in response.aiter_lines():
+                if not line or not line.startswith("data:"):
+                    continue
+
+                data = line.removeprefix("data:").strip()
+                if data == "[DONE]":
+                    break
+
+                payload = json.loads(data)
+                choices = payload.get("choices") or []
+                if not choices:
+                    continue
+
+                delta = choices[0].get("delta") or {}
+                content = delta.get("content")
+                if content:
+                    yield content

multimind-0.1.0/multimind/main.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+from thinking_wrapper.config import APP_NAME, DEFAULT_HOST, DEFAULT_PORT, PIPELINE_STEPS, STATIC_DIR, TEMPLATE_DIR
+from thinking_wrapper.discovery import ProviderInfo, discover_providers, normalize_base_url, select_default_provider
+from thinking_wrapper.llm_client import LocalLLMClient
+from thinking_wrapper.pipeline import run_pipeline
+
+
+class SettingsPayload(BaseModel):
+    provider_name: str = ""
+    provider_kind: str = "ollama"
+    base_url: str = "http://127.0.0.1:11434"
+    model_map: dict[str, str] = Field(default_factory=dict)
+
+
+class ChatRequest(BaseModel):
+    message: str = Field(min_length=1)
+    mode: str = Field(default="hard")
+
+
+@dataclass
+class RuntimeState:
+    providers: list[ProviderInfo] = field(default_factory=list)
+    settings: SettingsPayload = field(default_factory=SettingsPayload)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "providers": [provider.to_dict() for provider in self.providers],
+            "settings": self.settings.model_dump(),
+        }
+
+
+app = FastAPI(title=APP_NAME)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+app.state.runtime = RuntimeState()
+app.state.llm_client = LocalLLMClient()
+
+
+def _default_model_map(provider: ProviderInfo | None) -> dict[str, str]:
+    model = provider.models[0] if provider and provider.models else ""
+    return {step: model for step in PIPELINE_STEPS}
+
+
+def _merge_model_map(existing: dict[str, str], fallback: dict[str, str]) -> dict[str, str]:
+    merged: dict[str, str] = {}
+    for step in PIPELINE_STEPS:
+        merged[step] = existing.get(step) or fallback.get(step) or ""
+    return merged
+
+
+async def _refresh_runtime() -> None:
+    providers = await discover_providers()
+    runtime: RuntimeState = app.state.runtime
+    runtime.providers = providers
+    selected_provider = select_default_provider(providers)
+
+    if not runtime.settings.provider_name:
+        if selected_provider:
+            runtime.settings.provider_name = selected_provider.name
+            runtime.settings.provider_kind = selected_provider.kind
+            runtime.settings.base_url = selected_provider.base_url
+            runtime.settings.model_map = _default_model_map(selected_provider)
+        return
+
+    matching_provider = next(
+        (
+            provider
+            for provider in providers
+            if provider.name == runtime.settings.provider_name
+            and normalize_base_url(provider.base_url) == normalize_base_url(runtime.settings.base_url)
+        ),
+        None,
+    )
+
+    fallback_map = _default_model_map(matching_provider or selected_provider)
+    runtime.settings.model_map = _merge_model_map(runtime.settings.model_map, fallback_map)
+
+
+@app.on_event("startup")
+async def startup_event() -> None:
+    await _refresh_runtime()
+
+
+@app.on_event("shutdown")
+async def shutdown_event() -> None:
+    await app.state.llm_client.aclose()
+
+
+@app.get("/")
+async def index() -> FileResponse:
+    return FileResponse(Path(TEMPLATE_DIR) / "index.html")
+
+
+@app.get("/api/health")
+async def health() -> JSONResponse:
+    return JSONResponse({"ok": True})
+
+
+@app.get("/api/settings")
+async def get_settings() -> JSONResponse:
+    runtime: RuntimeState = app.state.runtime
+    return JSONResponse(runtime.to_dict())
+
+
+@app.post("/api/providers/refresh")
+async def refresh_providers() -> JSONResponse:
+    await _refresh_runtime()
+    runtime: RuntimeState = app.state.runtime
+    return JSONResponse(runtime.to_dict())
+
+
+@app.post("/api/settings")
+async def update_settings(payload: SettingsPayload) -> JSONResponse:
+    runtime: RuntimeState = app.state.runtime
+    runtime.settings = SettingsPayload(
+        provider_name=payload.provider_name,
+        provider_kind=payload.provider_kind,
+        base_url=normalize_base_url(payload.base_url),
+        model_map=_merge_model_map(payload.model_map, runtime.settings.model_map),
+    )
+    return JSONResponse(runtime.to_dict())
+
+
+@app.post("/api/chat/stream")
+async def chat_stream(request: ChatRequest) -> StreamingResponse:
+    runtime: RuntimeState = app.state.runtime
+    settings = runtime.settings
+    message = request.message.strip()
+    mode = request.mode.strip().lower()
+
+    if mode not in {"off", "medium", "hard"}:
+        raise HTTPException(status_code=400, detail="Mode must be one of off, medium, or hard.")
+
+    if not message:
+        raise HTTPException(status_code=400, detail="Message cannot be empty.")
+
+    async def event_stream():
+        try:
+            async for event in run_pipeline(
+                client=app.state.llm_client,
+                provider_kind=settings.provider_kind,
+                base_url=settings.base_url,
+                model_map=settings.model_map,
+                user_message=message,
+                mode=mode,
+            ):
+                yield json.dumps(event) + "\n"
+        except Exception as exc:
+            yield json.dumps({"type": "error", "message": str(exc)}) + "\n"
+
+    return StreamingResponse(event_stream(), media_type="application/x-ndjson")
+
+
+def run() -> None:
+    uvicorn.run(
+        "thinking_wrapper.main:app",
+        host=DEFAULT_HOST,
+        port=DEFAULT_PORT,
+        reload=False,
+    )

multimind-0.1.0/multimind/markdown_render.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import re
+
+import bleach
+import markdown
+
+
+_ALLOWED_TAGS = [
+    "a",
+    "blockquote",
+    "br",
+    "code",
+    "em",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "strong",
+    "table",
+    "tbody",
+    "td",
+    "th",
+    "thead",
+    "tr",
+    "ul",
+]
+
+_ALLOWED_ATTRIBUTES = {
+    "a": ["href", "rel", "target", "title"],
+}
+
+_ALLOWED_PROTOCOLS = ["http", "https", "mailto"]
+
+
+def _normalize_markdown(text: str) -> str:
+    normalized = text.replace("\r\n", "\n").replace("\r", "\n")
+    normalized = re.sub(r"(?m)^(\s*(?:[-*+]|\d+[.)]))\s*$\n+(\S)", r"\1 \2", normalized)
+    normalized = re.sub(r"\n{3,}", "\n\n", normalized)
+    return normalized.strip()
+
+
+def render_markdown_to_html(text: str) -> str:
+    normalized = _normalize_markdown(text)
+    raw_html = markdown.markdown(
+        normalized,
+        extensions=["extra", "sane_lists"],
+        output_format="html5",
+    )
+
+    return bleach.clean(
+        raw_html,
+        tags=_ALLOWED_TAGS,
+        attributes=_ALLOWED_ATTRIBUTES,
+        protocols=_ALLOWED_PROTOCOLS,
+        strip=True,
+    )