HyperChat

HyperChat treats AI agents as code artifacts defined through YAML configuration files that are version-controlled alongside project code in Git repositories. The system parses workspace-scoped agent definitions, manages agent lifecycle through a dedicated Agent Manager, and enables agents to maintain project-contextual memory and tool bindings. This 'AI as Code' philosophy allows agents to be portable, reproducible, and integrated into standard development workflows without cloud dependencies.

HyperChat implements a monorepo architecture with separate CLI and Web frontends that both consume the same core backend services (Agent Manager, MCP Manager, AI Channel). The CLI interface prioritizes agent-centric rapid interactions without workspace setup overhead, while the Web interface (built with React/Electron) provides multi-workspace management, collaborative features, and visual workspace configuration. Both interfaces share the same underlying service layer through a clean dependency hierarchy (shared types → core services → UI packages).

HyperChat uses a TypeScript monorepo structure with npm workspaces, implementing a sequential build process where packages build in dependency order: shared types → core services → UI packages (Web, Electron, CLI). The build system uses npm scripts orchestrated through package.json, with development mode supporting concurrent package development and hot reloading. The dependency hierarchy ensures clean separation of concerns with shared types as the foundation, preventing circular dependencies.

HyperChat implements Docker support for containerized deployment, with Dockerfile configurations for building container images that include Node.js runtime, dependencies, and the compiled application. The system includes CI/CD pipeline definitions (likely GitHub Actions or similar) that automate building, testing, and deploying containers. Container deployment enables HyperChat to run in Kubernetes, Docker Compose, or cloud platforms without requiring local Node.js installation.

HyperChat implements internationalization support enabling the Web UI to be rendered in multiple languages through a translation system. The system uses language-specific resource files (likely JSON or similar) that map UI strings to translated text, with language selection in the Web interface. The CLI and core services may have limited i18n support, with primary focus on Web UI localization.

HyperChat abstracts multiple LLM providers (OpenAI, Anthropic, Ollama, and others) through a unified AI Channel system that handles provider-agnostic chat streaming, token counting, and model selection. The system uses a provider configuration layer that maps API credentials to model endpoints, implements streaming response handling through Node.js streams, and maintains conversation history with context windowing. Chat messages flow through the AI Channel which normalizes provider-specific response formats into a common interface.

HyperChat implements the Model Context Protocol (MCP) standard to enable AI agents to invoke external tools and access local resources through a managed client lifecycle system. The MCP Manager instantiates and manages MCP client connections, the MCP Gateway exposes MCP tools via HTTP API for remote access, and agents can bind specific tools through workspace configuration. Tools are discovered through MCP server introspection, validated against schemas, and executed with automatic error handling and response streaming.

HyperChat implements a Workspace Manager that provides project-level isolation for agents, tools, and configurations through a hierarchical directory structure. Each workspace maintains its own agent definitions, MCP tool bindings, settings, and conversation history in a dedicated folder. The system supports multiple concurrent workspaces with independent AI provider configurations, enabling teams to manage different projects with different tool sets and agent behaviors without cross-contamination.

HyperChat's Agent System implements a command-based execution model where agents process user commands through a structured pipeline: command parsing, context loading (including workspace history and agent memory), LLM invocation, tool calling, and response streaming. Agent memory is persisted to disk using a conversation history store, enabling agents to maintain context across sessions. The system supports both synchronous command execution (CLI) and asynchronous streaming (Web), with automatic memory truncation for context window management.

HyperChat's CLI interface prioritizes rapid agent interaction without workspace setup overhead, implementing a command-line parser that maps user input to agent commands, streams responses in real-time using Node.js streams, and provides minimal configuration requirements. The CLI supports both interactive mode (REPL-like conversation) and command mode (single-shot execution), with automatic workspace detection and agent selection. Streaming output is rendered progressively to the terminal, enabling users to see agent responses as they generate.

HyperChat's Web interface (built with React and Electron for desktop) provides a visual workspace management system where users can create/edit workspaces, configure agents, manage MCP tool bindings, and view conversation history through a dashboard. The interface implements a project-centric navigation model with workspace switcher, agent list, and chat panel. The backend serves the Web UI through Express.js or similar, providing REST/WebSocket APIs for real-time updates and workspace synchronization.

HyperChat implements a Settings Manager that abstracts configuration across CLI environment variables, workspace YAML files, and application settings files. The system supports provider-specific configuration (API keys, model names, endpoints) with environment variable interpolation, enabling users to configure multiple LLM providers without hardcoding credentials. Settings are loaded in a hierarchical order (defaults → workspace config → environment variables), with environment variables taking precedence for security.

HyperChat implements a file-based conversation history store that persists chat messages to disk in a structured format (likely JSON or similar), enabling agents to load and reference previous conversations. The system implements context windowing by truncating old messages when conversation history exceeds the LLM's token limit, using a simple FIFO (first-in-first-out) strategy. Conversation history is workspace-scoped and agent-scoped, allowing different agents to maintain separate conversation threads.