VicroCode
Make Code Create Value
VicroCode is a lightweight online platform for publishing, running, sharing, and monetizing code projects. Launch HTML, Python, SQLite, AI agents, management tools, games, and more without server setup.
Please wait while VicroCode loads. You can also explore the AI programming guide
Loading...

AI MARKET GUIDE

Build a Lazy-Loaded Tool Directory for AI Coding Agents

A compact Python dispatcher and hosted HTML inspection page can make large tool catalogs easier to navigate, without claiming full MCP compatibility or proven context savings.

A useful pattern is emerging in small AI tools: keep the front door simple, then reveal detail only when someone needs it. One community project, mcp-meta, describes folding 104 tools from 14 servers into two on-demand tools. That is a specific project’s reported result, not a general benchmark. The practical idea is still worth borrowing: give an agent a compact directory, let a person inspect schemas on demand, and route selected calls through a controlled endpoint.

For a small AI coding project, this can be built as a Python dispatcher with a hosted HTML inspection page. It is a directory and routing pattern, not a claim of full MCP compatibility, broad upstream-server support, or measured performance gains.

Why make tool details lazy?

A directory that separates discovery from detail can make a large tool collection easier to inspect. In the mcp-meta project description, the author says a setup with 14 servers and 104 tools used 142,000 characters of schemas before the prompt, then reports 892 characters per request after introducing two lazy-loading tools, a 99.4% reduction. Those are reported measurements for that project; they are not verified independently here and should not be presented as what a new implementation will achieve.

The more general design lesson is modest: an agent often needs to know what tools exist before it needs every parameter definition. A compact listing can show a tool name and a short signature, such as `search(query: string, [limit: integer])`. The operator can request the full schema when selecting a tool, then make a call through an explicit dispatcher. That adds a discovery step, and the dispatcher becomes another component to test and maintain.

Other community posts point to adjacent needs, not proof of this exact problem’s scale. One developer described a 49-tool Telegram service; another shared a browser-agent project that exposes structured page information and actions. Together with the 104-tool directory example, these show several forms of tool-rich agent work. They do not establish how common schema overhead is across users or products; that broader market claim is unverified.

How would you build the prototype?

Start with a small Python registry and a separate HTML inspection page. The registry can hold each tool’s name, short signature, full schema, and a dispatcher function or in-platform tool-call target. A Python endpoint can return a compact index by default, return the detailed schema for a selected tool, and accept a selected call for controlled routing. Use Python execution for the dispatcher and API Endpoint Hosting and in-platform tool calls for the request path.

The HTML page can show the available tools in a scannable list. Selecting one can request its full schema from the endpoint and display the fields before the operator submits a call. Host and publish that page as an HTML app; a builder can run HTML online while iterating on the interface. Python-side experiments can be developed with run Python online.

Keep the prototype deliberately narrow. For a first pass, use a few hand-defined tools and deterministic mock responses. Add file management if tool definitions need to be edited as files, or SQLite if the directory needs an editable local catalog. VicroCode also supports LanceDB knowledge bases, but a searchable knowledge base is not necessary for a simple tool registry. Do not imply that this setup can connect to arbitrary MCP servers, use stdio, implement protocol negotiation, or support SSE and session handling: those capabilities are outside the confirmed scope here.

Where should the boundary sit?

The boundary should be explicit: this is a controlled directory and dispatcher, not a drop-in replacement for a full MCP proxy. The mcp-meta post describes stdio front-end support and stdio plus HTTP backends, including SSE, sessions, pagination, and protocol fallback. Those are claims about that project, not capabilities to assume for this VicroCode prototype.

Likewise, do not promise lower token use or faster responses. A compact index sends less descriptive content than a full catalog by design, but the actual request size and any effect on cost or performance depend on the implementation and calling workflow. Those outcomes are unverified until measured in a real setup. A practical evaluation would record the exact schemas returned for an index request and a detail request, and test whether selected calls reach the intended tool with expected inputs.

For operators, the trade-off is visibility versus convenience. Lazy detail keeps the initial directory compact, but users must inspect a schema before using a tool they do not know. A controlled endpoint makes the routing point visible, but it also needs careful input validation and clear error responses. Those are design responsibilities, not capabilities to assume automatically.

FAQ

Does this prototype support MCP?

No full MCP compatibility is established. It is a Python dispatcher and hosted HTML inspection page using only the confirmed execution, hosting, endpoint, and in-platform tool-call capabilities.

Will lazy loading cut token use by 99.4%?

That figure is reported by the mcp-meta project for its own setup. A VicroCode prototype’s savings are unverified until its requests are measured.

Can it connect to any tool server?

That is outside the confirmed scope. The design should route only to tools available through the prototype’s configured in-platform calls.

Further reading