╔══════════════════════════════════════════════════════════════════╗
║ ❄️ COLD WIND AI ❄️ ║
║ Multi-Platform AI System — Desktop today, Server + Mobile ║
║ uv Workspace • LangGraph • MCP • Browser Automation ║
╚══════════════════════════════════════════════════════════════════╝
Multi-platform AI system (desktop today; server + mobile planned) built on a uv-workspace monorepo, with multi-agent orchestration, dynamic MCP integration, hybrid AI models, and browser automation.
- 🧩 Quick Mental Model
- 🧠 The Brain & Body Architecture
- 🌐 Multi-Platform Ecosystem Matrix
- 🚀 What's New
- ✨ Current Status
- 🌟 What Makes This Special
- ⚡ Slash Commands
- 🛠️ Tool Ecosystem
- 🔧 Dynamic MCP Integration
- ⚙️ Configuration
- 🚀 Quick Start & Installation
- 🧊 uv Workspace & Platform Layering
- 🗺️ Project Architecture
- 🔄 Data Flow
- 🤖 Agent Workflow
- 📝 Logging System
- 🎯 Roadmap
- 📄 License
Cold Wind AI decouples cognitive intelligence from presentation runtimes:
┌────────────────────────────────────────────────────────────────────────┐
│ THE BRAIN: coldwind-core │
│ LangGraph Agents • Tool Orchestrator • MCP • Ticket Lifecycle │
└───────────────────────────────────┬────────────────────────────────────┘
│ PlatformRuntimeContextInterface
┌───────────────────────────┼───────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ BODY 1 (CLI) │ │ BODY 2 (GUI) │ │ BODY 3 (Cloud)│
│ prompt_tk │ │ Slint + Rust │ │ FastAPI (SSE) │
│ & Rich CLI │ │ 60 FPS Native │ │ (Planned) │
└───────────────┘ └───────────────┘ └───────────────┘
| Feature | Description |
|---|---|
| 🧊 Monorepo Restructure (Phase 1) | uv workspace with coldwind-core + coldwind-desktop namespace packages; uv sync installs everything |
| 🧱 Core–Desktop Decoupling | Desktop imports Core; Core never imports Desktop — platform contracts live in core/interfaces/ |
| 🧹 Dead-Code Purge | ~6,800 lines of legacy code removed: AgentGraphCore.py, flat global settings.py, socket debug pipeline (socket_manager.py, error_transfer.py), orphaned UI diagnostics modules |
| ⚙️ Runtime Context Registry | Live state via ContextRegistry — clean split between DesktopConfig (pure config) and DesktopRunTimeContext (runtime objects) |
| 🖥️ Dashboard Transport | Modernized debug dashboard transport, stream framing, and configuration paths |
| Feature | Description |
|---|---|
| ⌨️ Modern CLI Input | Beautiful autocomplete with prompt_toolkit |
| 🎯 Slash Command Autocomplete | Type / to see dropdown with commands |
| ⚡ Custom Key Bindings | Tab/Enter/Escape for intuitive navigation |
| 🎨 Cursor/Warp Theme | Modern dark theme with purple accents |
| Feature | Description |
|---|---|
| 📝 Professional Logging | Multi-file routing with 84% code reduction |
| 🗂️ Category Logging | Separate files: MCP, API, Tools, Agent, Errors |
| 🔄 Dynamic Routing | Keyword-based automatic categorization |
| 🏗️ SOLID Architecture | Extensible handlers, formatters, routers |
| Feature | Description |
|---|---|
| 🌐 Browser Automation | browser-use integration for web tasks |
| ⚡ Slash Commands | Modular /clear, /help, /agent, /exit |
| 🔌 Dynamic MCP | .mcp.json server registration |
| 🛡️ Circuit Breaker | OpenAI retry/backoff/fallback |
| Component | Status | Details |
|---|---|---|
| 🧊 uv Workspace | ✅ | coldwind-core + coldwind-desktop + coldwind-slint-gui (v0.0.1); server WIP |
| 🤖 Agent Mode | ✅ | Hierarchical multi-agent orchestration |
| 🔌 MCP | ✅ | Dynamic via .mcp.json |
| 🌐 Browser | ✅ | browser-use integration |
| ⌨️ CLI Input | ✅ | Modern autocomplete via prompt_toolkit |
| 📝 Logging | ✅ | Multi-file with dynamic routing + rotation |
| 🐳 Docker | ⏳ | Dockerfile ready, compose WIP |
| 🧪 Tests | 🚧 | Unmaintained — regeneration planned (TODO) |
| 🐍 Python | 3.13+ | Managed by uv (no legacy 3.11 support) |
Cold Wind AI strictly separates cognitive intelligence from the presentation runtime:
- The Brain (
coldwind-core): The shared, headless cognitive microkernel. It owns LangGraph multi-agent orchestration, dynamic MCP server integration, tool execution, session state, and ticket lifecycle (TicketIn/TicketOut). It contains zero UI dependencies and zero console printing. - The Bodies (Platform Presentation Layers): Pluggable presentation interfaces that consume the Brain through the
PlatformRuntimeContextInterface:- Platform 1 — Desktop CLI (
coldwind-desktop): Full-featured terminal interface built withprompt_toolkitandrich. - Platform 2 — Native Slint Desktop GUI (
coldwind-slint-gui+ Rust Companion): High-performance GPU-accelerated desktop client built with Rust and Slint UI. - Platform 3 — Cloud Backend (
coldwind-server): Planned headless FastAPI service. - Platform 4 — Mobile Client: Planned Flutter client.
- Platform 1 — Desktop CLI (
flowchart TD
subgraph Brain ["THE BRAIN: Headless Agent Engine (coldwind-core)"]
CE["ColdWindEngine (TicketIn / TicketOut)"]
LG["LangGraph Agent Workflows"]
MCP["Dynamic MCP Protocol Manager"]
INF["Platform Runtime Contracts (Interfaces)"]
CE --- LG
CE --- MCP
CE --- INF
end
subgraph Body1 ["BODY 1: Desktop CLI (coldwind-desktop)"]
CLI["prompt_toolkit + Rich Terminal UI"]
DC["DesktopRunTimeContext"]
CLI --- DC
end
subgraph Body2 ["BODY 2: Native Desktop GUI (Rust + Slint)"]
direction TB
REPO["Repository: PIRATE-E/RUST_GUI-AI_TASK_WORKFLOW"]
SLINT["Slint UI (Thread 0: 60 FPS ListView)"]
RUST["Rust Worker Thread (Thread N: PyO3)"]
SC["SlintRuntimeContext (coldwind-slint-gui)"]
REPO --- SLINT
SLINT <-->|"sync_channel / invoke_from_event_loop"| RUST
RUST --- SC
end
subgraph Body3 ["BODY 3: Cloud & Mobile (Planned)"]
SRV["coldwind-server (FastAPI SSE)"]
MOB["Mobile Client (Flutter)"]
end
DC -->|"Implements Contract"| INF
SC -->|"Implements Contract"| INF
SRV -.->|"Implements Contract"| INF
MOB -.->|"Implements Contract"| INF
| Platform Target | Tech Stack | Status | Repository / Package |
|---|---|---|---|
| Platform 1: Terminal CLI | Python 3.13+, Rich, prompt_toolkit |
Production (v2.0.0) | Local: desktop/ (coldwind-desktop) |
| Platform 2: Native Desktop GUI | Rust 2024, Slint UI, PyO3 FFI | Milestone 0.0.1 Shipped | External: RUST_GUI-AI_TASK_WORKFLOW |
| Platform 3: Cloud Backend | Python, FastAPI, SSE streaming | Planned Skeleton | Local: server/ (coldwind-server) |
| Platform 4: Mobile Client | Dart, Flutter | Planned Roadmap | Dedicated mobile client |
┌─────────────────────────────────────────────────────────────────────────┐
│ CORE CAPABILITIES │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 🤖 HYBRID AI ─→ Ollama (local) + OpenAI/NVIDIA/Kimi (cloud) │
│ ⚡ AGENT MODE ─→ /agent multi-tool hierarchical orchestration │
│ 🌐 BROWSER ─→ Automated web browsing & interaction │
│ 🛠️ TOOLS ─→ Core tools + MCP-integrated + browser │
│ 📝 LOGGING ─→ Multi-file routing + dashboard transport │
│ ⌨️ CLI INPUT ─→ Modern autocomplete with styling │
│ 🎨 RICH UI ─→ Beautiful tracebacks & dashboard │
│ 🧊 WORKSPACE ─→ uv monorepo, core/desktop decoupled │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Note
Documentation Scope Notice: This README repository primarily details the shared Brain (coldwind-core) and the Desktop CLI Body (coldwind-desktop). For the native desktop GUI implementation, visit the companion repository: RUST_GUI-AI_TASK_WORKFLOW.
╭──────────────────────────────────────────────────────────────╮
│ COMMAND DESCRIPTION │
├──────────────────────────────────────────────────────────────┤
│ /help 📖 Show available commands │
│ /agent <task> 🤖 Multi-tool AI orchestration │
│ /clear 🧹 Clear conversation history │
│ /exit 👋 Gracefully exit application │
│ /tool 🔧 Use specific tool directly │
│ /chat 💬 Normal chat mode │
╰──────────────────────────────────────────────────────────────╯Usage Examples:
/agent search for Python tutorials and save to a file
/help
/clear
/exit| Category | Tools | Description |
|---|---|---|
| 🔍 Core | google_search, rag_search_classifier, translate, run_shell_command |
Search, RAG, translation, shell |
| 📂 MCP-Integrated | filesystem + universal wrappers | File operations & universal routing via MCP |
| 🌐 Browser | browser_tool |
Automated web browsing (browser-use) |
Tools are registered via core/src/coldwind/core/tools/lggraph_tools/tool_assign.py and exposed to the LangGraph agents.
Create .mcp.json at project root (this is the runtime MCP config — resolved via mcp_config_path on DesktopConfig, loaded by core/src/coldwind/core/mcp/load_config.py):
{
"servers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem@latest", "<PATH>"]
},
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory@latest"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github@latest"]
}
}
}Features:
- ✅ Auto-discovery and registration
- ✅ Universal MCP routing
- ✅ Dynamic tool→server mapping
- ✅ Robust subprocess I/O
Settings are typed pydantic-settings classes: CoreSettinngs in core/src/coldwind/core/config/coreSettings.py, extended by DesktopConfig in desktop/src/coldwind/desktop/config/DesktopConfig.py. They load from a .env file at the project root.
# ═══════════════════════════════════════════════════════════════
# API KEYS
# ═══════════════════════════════════════════════════════════════
OPENAI_API_KEY=your_openai_or_nvidia_key
# ═══════════════════════════════════════════════════════════════
# MODELS
# ═══════════════════════════════════════════════════════════════
DEFAULT_MODEL=nvidia/nemotron-3-ultra-550b-a55b
GPT_MODEL=openai/gpt-oss-120b
CLASSIFIER_MODEL=llama3.1:8b
CYPHER_MODEL=deepseek-r1:8b
KIMI_MODEL=moonshotai/kimi-k2.6
# ═══════════════════════════════════════════════════════════════
# TIMEOUTS
# ═══════════════════════════════════════════════════════════════
OPENAI_TIMEOUT=60
OPENAI_CONNECT_TIMEOUT=10
MCP_TIMEOUT=30
MCP_START_TIMEOUT=30
BROWSER_USE_TIMEOUT=1300
# ═══════════════════════════════════════════════════════════════
# NEO4J
# ═══════════════════════════════════════════════════════════════
NEO4J_URI=bolt://localhost:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=your_password
NEO4J_DATABASE=neo4j
# ═══════════════════════════════════════════════════════════════
# LOGGING
# ═══════════════════════════════════════════════════════════════
LOG_LEVEL=INFO
LOG_DISPLAY_MODE=separate_window
# ═══════════════════════════════════════════════════════════════
# FEATURES
# ═══════════════════════════════════════════════════════════════
BROWSER_USE_ENABLED=true
MCP_ENABLED=true
DEBUG=false
# ═══════════════════════════════════════════════════════════════
# SERVER
# ═══════════════════════════════════════════════════════════════
SOCKET_HOST=localhost
SOCKET_PORT=5390| Category | Setting | Default |
|---|---|---|
| API | OPENAI_API_KEY |
Required |
| Models | DEFAULT_MODEL |
nvidia/nemotron-3-ultra-550b-a55b |
| Models | GPT_MODEL |
openai/gpt-oss-120b |
| Timeout | OPENAI_TIMEOUT |
60s |
| MCP | MCP_TIMEOUT / MCP_START_TIMEOUT |
30s |
| Browser | BROWSER_USE_TIMEOUT |
1300s |
| Neo4j | NEO4J_URI |
bolt://localhost:7687 |
| Logging | LOG_LEVEL / LOG_DISPLAY_MODE |
INFO / separate_window |
Config vs runtime: settings classes hold pure configuration only. Live runtime objects (Neo4j driver, message classes, listeners, …) never live on settings — they are registered on the active runtime context via
ContextRegistry(see uv Workspace & Platform Layering).
The terminal interface runs directly from this monorepo:
# 1. Clone this repository
git clone https://github.com/PIRATE-E/ai-workflow-task-agent.git
cd ai-workflow-task-agent
# 2. Sync workspace dependencies via uv (installs coldwind-core, coldwind-desktop, and coldwind-slint-gui)
uv sync --all-packages
# 3. Configure your API keys in .env (see Configuration above)
cp .env.example .env
# 4. Launch the CLI application
uv run --package coldwind-desktop coldwindThe native GUI is built in Rust using Slint UI and embeds coldwind-core via PyO3:
# 1. Ensure ai-workflow-task-agent is cloned and synced (provides the Python Brain)
cd /path/to/ai-workflow-task-agent
uv sync --all-packages
# 2. Clone the companion Rust GUI repository
git clone https://github.com/PIRATE-E/RUST_GUI-AI_TASK_WORKFLOW.git
cd RUST_GUI-AI_TASK_WORKFLOW
# 3. Configure GUI environment (.env.slint)
cp .env.slint.example .env.slint
# 4. Compile and launch the native desktop application
cargo runThis is a uv workspace monorepo with namespace packages under coldwind.*:
ai-workflow-task-agent/
├── core/ → coldwind-core The Brain: Shared headless engine (Tickets, LangGraph, Tools, MCP)
├── desktop/ → coldwind-desktop Body 1: Desktop CLI layer (prompt_toolkit + rich, DesktopRunTimeContext)
├── slint_gui/ → coldwind-slint-gui Body 2: Native GUI Python bridge (SlintRuntimeContext, PyO3 FFI sinks)
└── server/ → planned Body 3: Cloud backend (declared workspace member skeleton)
Paired Companion Workspace:
RUST_GUI-AI_TASK_WORKFLOW (https://github.com/PIRATE-E/RUST_GUI-AI_TASK_WORKFLOW.git)
└── Native Rust binary + Slint GPU rendering (Thread 0) embedding coldwind-core via PyO3 (Thread N)
Layering invariant (enforced): Platform packages (desktop, slint_gui, server) import Core. Core never imports any Platform package. Core only knows the abstract contracts defined in core/interfaces/ — never concrete platform implementations.
Zero Presentation Leak Invariant: Core workflow nodes must never call direct platform presentation APIs (console.print). All node progress, routing notices, and slash command diagnostics route through print_message(content, sender="system") on the active MessageDisplayInterface.
Config vs runtime split:
- Pure configuration → pydantic-settings classes (
CoreSettings→DesktopConfig). - Live runtime objects → the active runtime context, obtained via
ContextRegistry.get(), with core services registered/retrieved through the dynamic enum-keyed store:context.register_service(CoreRunTimeObjects.<name>, value)/context.get_service(CoreRunTimeObjects.<name>).
The goal of this section is navigation. If you're new, start from Entry Points, then follow the arrows.
ENTRY (desktop) → CORE (engine/agents) → (SLASH | AGENT | TOOLS | MCP) → UI/DASHBOARD/LOGS
desktop/src/coldwind/desktop/
└── main_orchestrator.py ✅ Program entry (boot + wiring: config, runtime context, destructor)
core/src/coldwind/core/engine/
├── chat_initializer.py ✅ Boots the LangGraph graph, registers tools + slash commands
├── chat_destructor.py ✅ Cleanup (exit flow, shutdown)
└── graphs/
└── node_assign.py ✅ GraphBuilder(State).compile_graph()
core/src/coldwind/core/agents/
├── agent_mode_node.py # /agent orchestration node
├── classify_agent.py # route user input (chat/tool/agent/slash)
├── router.py # routing logic
├── tool_selector.py # selects tools for tasks
├── node_factory.py # builds graph nodes
├── chat_llm.py # talks to LLM
├── agents_schema/
│ └── agents_schema.py # typed schemas
└── agentic_orchestrator/ # hierarchical multi-agent orchestration
├── graphCore.py # core orchestrator (LangGraph workflow structure)
├── spawn_agent.py # hierarchical sub-agent spawner
├── agent_core_helpers.py # tool pre-filtering, schema resolution, execution helpers
├── agent_status.py # real-time task/workflow status notifications
├── pydantic_models.py # WorkflowStateModel, TASK, AgentState
└── hierarchical_agent_prompts.py # depth-aware prompt templates
desktop/src/coldwind/desktop/slash_commands/
├── parser.py # parse '/command args'
├── executionar.py # run command handler
├── protocol.py # SlashCommand dataclasses
├── on_run_time_register.py # runtime registration (singleton)
├── registry.py # command registry
└── commands/
├── help.py # /help
├── clear.py # /clear
├── exit.py # /exit
└── core_slashs/
├── agent.py # /agent
├── chat_llm.py # /chat
└── use_tool.py # /tool
core/src/coldwind/core/tools/lggraph_tools/
├── tool_assign.py # tool registration into the graph
├── tool_selector.py # tool selection for agent tasks
├── tool_response_manager.py # response handling
├── tools/
│ ├── google_search_tool.py
│ ├── translate_tool.py
│ ├── run_shell_command_tool.py
│ ├── rag_search_classifier_tool.py
│ ├── browser_tool_main.py
│ ├── browser_tool/ # Handler, runner, config, utils/, subprocess runner
│ └── mcp_integrated_tools/
│ ├── filesystem.py
│ └── universal.py
├── wrappers/
│ ├── google_wrapper.py
│ ├── translate_wrapper.py
│ ├── browser_use_wrapper.py
│ ├── rag_search_classifier_wrapper.py
│ ├── run_shell_comand_wrapper.py
│ └── mcp_wrapper/
│ ├── filesystem_wrapper.py
│ └── uni_mcp_wrappers.py
└── tool_schemas/
└── tools_structured_classes.py
core/src/coldwind/core/mcp/
├── load_config.py # reads .mcp.json from project root
├── manager.py # starts/stops MCP servers
├── mcp_manager_util.py # manager helpers
├── dynamically_tool_register.py # registers discovered MCP tools
└── mcp_register_structure.py
.mcp.json # MCP servers config (project root)
core/src/coldwind/core/system_logging/
├── protocol.py # LogEntry + enums (LogCategory, LogLevel)
├── adapter.py # protocol conversion
├── router.py # keyword-based routing
├── dispatcher.py # dispatch to handlers
├── formatter.py # formatting
├── registry.py / on_time_registry.py
├── handlers/
│ └── handler_base.py # TextHandler (+ rotation)
└── debug_protocol/
├── debug_callers_api.py # developer-facing debug_* API (see Logging System below)
└── dashboard_transport/ # live dashboard streaming
basic_logs/ # per-category output files
├── log_MCP_SERVER.txt
├── log_API_CALL.txt
├── log_TOOL_EXECUTION.txt
├── log_AGENT_WORKFLOW.txt
├── log_ERROR_TRACEBACK.txt
└── log_OTHER.txt
desktop/src/coldwind/desktop/dashboard/
├── dashboard_handler.py # dashboard event handling
├── dashboard_printer.py # rich rendering
├── dashboard_transport.py # stream framing + transport
└── runner_server.py # local dashboard server
desktop/src/coldwind/desktop/ui/
├── chatInputHandler.py # ⌨️ prompt_toolkit input + autocomplete
├── print_banner.py # startup banner
├── print_message_style.py # user/ai/tool message panels
└── diagnostics/
└── rich_traceback_manager.py # beautiful exception tracebacks
core/src/coldwind/core/utils/
├── model_manager.py # model loading/switching (Ollama + OpenAI)
├── open_ai_integration.py # OpenAI/NVIDIA integration + circuit breaker
├── argument_schema_util.py # tool argument schema helpers
├── timestamp_util.py # formatted timestamps for logging
└── listeners/
├── event_listener.py # observer-pattern events
├── exit_listener.py # two-ticket graceful shutdown
└── rich_status_listen.py # rich status updates
core/src/coldwind/core/RAG/
└── RAG_FILES/
├── rag.py
├── neo4j_rag.py
└── sheets_rag.py
core/src/coldwind/core/
├── runtime/
│ ├── CoreContextRegistry.py # ContextRegistry — active runtime context lookup
│ └── runtime_obj_enum.py # CoreRunTimeObjects — dynamic service store keys
├── interfaces/ # platform contracts (Core knows ONLY these)
│ ├── runtime_interface.py
│ ├── ui_interface.py
│ ├── exception_interface.py
│ └── logging_interface.py
├── models/
│ └── state.py # shared state models
└── prompts/ # prompt modules (agent, chat, RAG, tool selector, web search, …)
desktop/src/coldwind/desktop/
├── config/
│ └── DesktopConfig.py # desktop settings (extends CoreSettinngs)
└── runtime/
└── DesktopContext.py # DesktopRunTimeContext (active runtime context)
tests/ 🚧 UNMAINTAINED — test-suite regeneration is planned (TODO).
The current
tests/tree predates the monorepo restructure and is scheduled to be regenerated. Do not treat it as documentation of the current architecture.
graph TD
A[🎯 desktop main_orchestrator.py] --> B[🎬 ChatInitializer]
B --> C[⌨️ InputHandler]
C --> D{📋 Route Decision}
D -->|💬 Chat| E[🤖 LLM Agent]
D -->|🛠️ Tool| F[🔧 Tool Selector]
D -->|⚡ Agent| G[🎯 Agent Orchestrator]
D -->|⚡ Slash| H[⚡ Command Executor]
F --> I[📂 MCP Tools]
F --> J[🔍 Core Tools]
F --> K[🌐 Browser Tool]
G --> L[🧠 AI Parameter Gen]
L --> M[🔄 Tool Chain]
M --> N[📊 Evaluation]
E --> O[🎨 Rich Output]
F --> O
N --> O
H --> O
O --> P[💻 User Interface]
sequenceDiagram
participant U as 👤 User
participant M as 🤖 Main Agent
participant S as 🔄 Sub-Agent
participant T as 🛠️ Tools
participant R as 🎨 Rich UI
U->>M: /agent complex task
M->>M: 🎯 Analyze & Plan
M->>S: 🚀 Spawn sub-agent
loop For each subtask
S->>T: 🛠️ Execute tool
T->>S: 📤 Return result
S->>R: 📊 Update status
end
S->>M: ✅ Report completion
M->>R: 📋 Final report
R->>U: 🎨 Rich output
The developer-facing API lives in core/system_logging/debug_protocol/debug_callers_api.py:
from coldwind.core.system_logging.debug_protocol.debug_callers_api import (
debug_info,
debug_warning,
debug_error,
debug_critical,
)
debug_info("MCP • SERVER_STARTED", "GitHub server started successfully")Each call builds a typed LogEntry(category, level, timestamp, message, metadata) and hands it to the Dispatcher, which routes it to the registered handlers:
┌─────────────────────────────────────────────────────────────────────────┐
│ PROFESSIONAL LOGGING ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Your Code │
│ │ debug_info / debug_warning / debug_error / debug_critical │
│ ▼ │
│ LogEntry(category, level, timestamp, message, metadata) │
│ │ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ Dispatcher │ ──→ routes the entry │
│ └────────┬────────┘ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ Router │ ──→ keyword/category-based routing │
│ └────────┬────────┘ │
│ ▼ │
│ ┌─────────────────┐ ┌────────────────────────────────────────┐ │
│ │ TextHandler │───→│ log_MCP_SERVER.txt (MCP logs) │ │
│ │ (with rotation)│──→│ log_API_CALL.txt (API logs) │ │
│ │ │───→│ log_TOOL_EXECUTION.txt (Tool logs) │ │
│ │ │───→│ log_AGENT_WORKFLOW.txt (Agent logs) │ │
│ │ │───→│ log_ERROR_TRACEBACK.txt (Errors) │ │
│ │ │───→│ log_OTHER.txt (Other logs) │ │
│ └─────────────────┘ └────────────────────────────────────────┘ │
│ │
│ Live view: debug_protocol/dashboard_transport → desktop dashboard │
│ Files land in basic_logs/ with size/time-based rotation │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Features: clean separation of concerns (protocol, adapter, router, dispatcher, formatter, handlers, registry), extensible handlers, file rotation, and a live dashboard transport.
- Major RAG ETL refinement — modern, optimized ingestion pipeline (next up)
- API Server (FastAPI backend)
- Security hygiene pass
- Browser UX improvements
- Complete Docker deployment
- REST API for integrations
- Multi-agent collaboration
- Extended MCP server support
- Server + mobile platforms (Flutter)
- Tool marketplace (click-to-install tools)
- Advanced reasoning
- Industry-specific solutions
- Open-source ecosystem
MIT License - See LICENSE for details.
🔮 Next up: a major RAG ETL refinement — modern & optimized.
Cold Wind AI v2.0.0 · October 2026