MonkeyCode

Provides real-time chat-based code generation within VSCode and JetBrains IDEs through a WebSocket-based LLM proxy architecture that maintains session state, tracks token usage, and routes requests to configurable model providers (OpenAI, Anthropic, local models). The system captures active file context, cursor position, and workspace state to inject into prompts, enabling developers to request code generation without leaving their editor. Requests flow through a layered backend architecture with dependency injection (Wire framework) that handles authentication, model selection, and response streaming.

Delivers context-aware autocomplete suggestions by indexing the entire codebase via a CLI tool that builds semantic representations, then injecting relevant code context into completion requests. The system uses a completion flow that captures cursor position, surrounding code, and indexed codebase symbols to generate suggestions matching the developer's coding style and project patterns. Completions are streamed back to the IDE plugin with latency optimization through local model support and request batching.

Implements a clean layered architecture (handlers, services, repositories) using Google Wire for dependency injection, enabling testability and loose coupling between components. The system uses centralized error handling with localization support for multi-language error messages, and structured logging for debugging. The architecture separates concerns: HTTP handlers for request routing, service layer for business logic, repository layer for data access, and provider layer for external integrations (LLM APIs, Git platforms).

Implements a relational database schema with tables for users, workspaces, files, API keys, sessions, usage records, audit logs, and security scan results. The schema supports multi-tenancy through workspace isolation, enabling multiple teams to use the same MonkeyCode instance with data separation. Foreign key relationships enforce referential integrity, and indexes on frequently-queried columns (user_id, workspace_id, timestamp) optimize query performance. The schema design supports both PostgreSQL and MySQL deployments.

Provides a command-line tool that scans a codebase, extracts semantic symbols (functions, classes, imports), and builds an index stored in the backend database. The tool uses language-specific parsers (AST-based for supported languages) to extract definitions and relationships, enabling context-aware code completion and search. The index includes symbol metadata (name, type, location, usage frequency) and can be queried by the IDE plugins for context injection. The tool supports incremental indexing for fast updates on code changes.

Implements centralized configuration management using YAML files for defining LLM providers, models, authentication credentials, and deployment settings. The configuration system supports environment variable substitution for secrets (API keys), enabling secure deployment without hardcoding credentials. Configuration is loaded at server startup through a configuration loader that validates schema and applies defaults. The system supports hot-reloading of non-critical settings (model weights, load balancing policies) without server restart.

Scans code for security vulnerabilities during development using a queue-based scanning architecture that integrates with Chaitin's SGP (Security Governance Platform) scanner service. The system processes scan requests asynchronously, storing results in the database and exposing them through the IDE plugin and management dashboard. Scanning can be triggered on-demand or integrated into CI/CD pipelines, with results tracked per file, commit, and user for audit and compliance purposes.

Deploys AI employees as bots on GitHub, GitLab, Gitee, and Gitea that respond to commands (e.g., @monkeycode-ai review) to perform code review, issue breakdown, and feature implementation. The system integrates with Git platform APIs to fetch PR diffs, issue descriptions, and repository context, then uses the LLM proxy to generate reviews or implementation suggestions. Results are posted back as PR comments or issue updates, with full audit trail and user attribution stored in the database.

Manages a configurable registry of LLM providers (OpenAI, Anthropic, local models) with dynamic model selection and load balancing logic. The system stores provider credentials and model configurations in the database, allowing administrators to switch models, adjust pricing, and balance load across providers without code changes. Request routing uses configurable policies (round-robin, cost-optimized, latency-optimized) to distribute completion and chat requests across available models, with fallback to secondary providers on failure.

Maintains synchronized state between IDE workspace and backend through WebSocket connections that track file changes, deletions, and renames. The system uses a file operation API to persist workspace metadata in the database and trigger incremental indexing updates. Changes are broadcast to all connected clients for a given workspace, enabling real-time collaboration awareness and consistent context for AI operations. The CLI indexing tool integrates with this system to build semantic indexes from synchronized file state.

Records all LLM API requests with token counts, model selection, and user attribution in the database, enabling detailed usage analytics and billing reports. The system implements token counting at the LLM proxy layer before and after requests, tracking input/output tokens separately. Billing queries aggregate usage by user, model, provider, and time period, supporting flexible billing models (per-token, per-request, subscription). The management dashboard exposes usage trends, cost breakdowns, and audit logs for compliance and cost optimization.

Implements multi-factor authentication using OAuth (GitHub, GitLab, Google) and API key-based authentication for programmatic access. The system stores user profiles, API keys, and session tokens in the database with role-based access control (RBAC) for workspace and admin operations. Authentication flows use standard OAuth 2.0 with PKCE for web clients and API key validation for IDE plugins and CLI tools. Session management includes token expiration, refresh token rotation, and logout with session revocation.

Provides a web-based interface for administrators to view usage analytics, audit logs, security scan results, and configure AI models and providers. The dashboard implements real-time data visualization using React frontend with backend API endpoints for querying usage, billing, and audit data. Administrators can manage user roles, API keys, workspace settings, and model provider credentials through the UI. The dashboard supports exporting reports in CSV and JSON formats for compliance and cost analysis.

Implements native IDE plugins for VSCode and JetBrains that integrate with the MonkeyCode backend through WebSocket connections for real-time chat, code completion, and security scanning results. The plugins use IDE-native APIs to capture editor context (cursor position, selected text, file path), display streaming responses with syntax highlighting, and manage local state for conversation history. The architecture supports offline graceful degradation and automatic reconnection on network recovery.