VCP (Variable & Command Protocol): A New-Generation AI Capability Enhancement and Evolution Middleware Layer

Forum topic · ✨步子哥 · 2025-10-01

Summary

VCP (Variable & Command Protocol) is an open middleware layer designed to enhance AI model capabilities beyond traditional chat interactions. It deeply integrates AI reasoning, external tool execution, and persistent memory systems at the API layer, forming an 'AI-tool-memory' triangle that works across model types, modalities, and frontends. Key features include a powerful plugin architecture driven by plugin-manifest.json manifests; a text-based tool-calling protocol (TOOL_REQUEST blocks with a distinctive 「始」value「末」parameter format) that works model-agnostically without relying on vendor-specific function calling; MCP compatibility via an MCPO-based translation port so existing Model Context Protocol plugins run unmodified; a centralized WebSocket service for real-time bidirectional communication; and a model whitelist passthrough mechanism for non-standard models such as image generation and embedding models. The architecture is organized into five layers: application, interaction, protocol, execution, and infrastructure. The project also warns users against routing API calls through unofficial mirror or proxy services, since VCP holds deep system-level monitoring access and such practices risk leaking sensitive data.

Introduction

VCP (Variable & Command Protocol) is a middleware layer designed to go beyond conventional AI interaction patterns. Beyond being a highly compatible, general-purpose, extensible toolbox, it aims to be an ecosystem that enables AI models to achieve capability leaps, memory evolution, and emergent swarm intelligence. The project's stated goal is a universal VCP system that is not restricted by model type, modality, or frontend, deeply integrating AI reasoning, external tool execution, and persistent memory at the API level to form an efficient "AI–tool–memory" triangle.

Key points

1. Plugin-based architecture

Plugins are defined via plugin-manifest.json and managed by a core plugin manager (Plugin.js), enabling integration of existing APIs, professional software, hardware interfaces, or custom logic.
Example manifest entries include a WebSearch plugin (parameters: query, maxResults) and a CodeExecution plugin (parameters: code, language).

2. VCP command protocol

AI models invoke tools by embedding text markers in their replies: <<<[TOOL_REQUEST]>>> ... <<<[END_TOOL_REQUEST]>>>.
Parameters use the format key:「始」value「末」, which supports complex data types and multi-line text robustly.
Parameter key parsing is case-insensitive and ignores separators like underscores and hyphens, so image_size, imagesize, ImageSize, and IMAGE-SIZE are all recognized as the same parameter.
Being purely text-marker based, it avoids dependence on vendor-specific Function Calling API fields, achieving broad model compatibility.

3. MCP compatibility via MCPO

An MCPO-based (Model Context Protocol Opera) compatibility port translates MCP tool call formats into VCP commands in real time and handles the responses.
Existing MCP plugins run in the VCP environment without modification, positioning VCP as a "meta-protocol" unifying different AI capability layers.

4. Unified WebSocket communication

A centralized service (WebSocketServer.js) handles all WebSocket connections, authentication, and message broadcasting.
Service plugins (e.g., VCPLog) and sync plugins (via webSocketPush config) push logs, AI messages, and status updates without implementing their own WebSocket servers.
Supports targeted broadcasting by clientType, letting different frontends subscribe to specific message types.

5. Model whitelist passthrough

Configured in config.env via WhitelistImageModel and WhitelistEmbeddingModel (comma-separated lists).
Requests to whitelisted models are routed through specialModelRouter.js, bypassing all normal processing (preprocessing, variable substitution, tool-call loops).
Embedding model requests are forwarded untouched (true passthrough); image model requests may receive necessary modifications (e.g., adding a generationConfig) before forwarding.

6. Five-layer architecture

1. Application Layer — APIs and SDKs for developer integration (e.g., a VCPClient with endpoint, API key, and model config). 2. Interaction Layer — Request Processor (variable substitution, context management), Response Parser (tool-call detection), and Session Manager (conversation history and state). 3. Protocol Layer — the VCP command protocol itself. 4. Execution Layer — plugin invocation and tool execution. 5. Infrastructure Layer — storage, networking, and base services.

Security warning

The author issues a strong warning against calling the toolbox through unofficial or reverse-proxied APIs (mirror sites, third-party relay API providers). Because VCP has near system-level monitoring access, doing so risks leaking sensitive information — AI interaction data, memory-base contents, API keys, browser history, and credentials — to untrusted third parties. Users are advised to keep their AI model API call chains clean, direct, and trusted.

Conclusion

VCP positions itself as a bridge toward AI agents that can learn autonomously, evolve continuously, and collaborate efficiently with other agents, all built on private and shared knowledge bases, with the aim of expanding the application boundaries and intelligence potential of AI systems.