Customized MCP Servers

Idea / Feature Request: Workspace-Specific MCP Tools — Eliminate Repeated Schema Discovery

First, Fibery’s MCP server is excellent. It makes a highly customizable workspace accessible to AI agents without requiring a bespoke integration for every workspace. But I think there’s an opportunity for a significant improvement in efficiency, speed, and cost.

The Problem

Fibery’s greatest strength is its flexible ontology. Every company can build its own databases, fields, relationships, and workflows.

Naturally, the MCP server must be generic. An AI agent connecting to an unfamiliar workspace needs to discover its schema, understand the relationships, identify the relevant fields, formulate queries, and then perform the requested operation.

That makes sense for initial discovery. But for an established workspace, the ontology is relatively stable. Why should every AI agent have to rediscover what the company has already defined?

For example, suppose I ask an AI agent to retrieve a Project and all the related Tasks, Matters, and other linked records.

Depending on what the agent already knows, it may need to:

  1. Discover the available databases.

  2. Examine the Project schema.

  3. Examine the related databases and their fields.

  4. Determine the correct relationships and query syntax.

  5. Query the Project and associated entities.

  6. Assemble the results into the requested format.

Now imagine repeating this across multiple conversations, agents, models, and users.

We have already established what a Project is, what entities relate to it, and how those relationships work. Yet the agents repeatedly expend tokens and tool calls reconstructing that knowledge.

This adds latency, consumes context, increases LLM token costs, and potentially increases the number of API operations Fibery must process. Depending on how the AI is hosted, some of these costs fall on customers and some may fall on Fibery.

The Idea: Workspace-Defined MCP Tools

What if Fibery allowed workspace administrators to define custom MCP tools based on the workspace’s actual ontology?

Instead of requiring the agent to discover and reconstruct a query, the MCP server could expose tools such as:

  • get_project(project_id) — Retrieve a Project with a predefined set of relevant fields.

  • get_project_context(project_id) — Retrieve the Project and its associated Tasks, Matters, documents, and other relevant entities.

  • update_project_plan(project_id, changes) — Apply a defined set of permissible changes to a Project’s plan.

  • get_widget(widget_id) — Retrieve a workspace-specific entity.

  • get_project_widgets(project_id) — Retrieve all such entities related to a Project.

These tools would be configured once, against the actual Fibery schema, and subsequently made available to every authorized AI agent connected to that workspace.

A request such as “Get me everything related to Project X” could invoke get_project_context directly instead of launching another cascade of schema discovery, relation mapping, and query construction.

The intelligence about how the workspace works would live in Fibery, where it belongs, rather than being repeatedly reconstructed by external models.

How Might This Work?

I’m not sure whether the best implementation would be custom instructions, saved queries, custom MCP tools, or a generated workspace-specific MCP server.

One possibility would be an administrative interface where we could:

  1. Define a tool with a name, description, and typed inputs.

  2. Bind it to the ontology, selecting databases, relationships, fields, filters, and operations.

  3. Define the output, returning only the information the agent needs instead of large generic responses.

  4. Expose it through MCP, alongside Fibery’s existing generic tools.

  5. Maintain it automatically, with validation or warnings when the underlying schema changes.

More complex tools might invoke several Fibery operations internally, including existing automations or saved queries.

Custom instructions or a workspace schema manifest could be a simpler starting point. But executable tools would provide more substantial benefits because they would eliminate not just repeated discovery but also repeated query generation and orchestration.

The generic MCP tools should remain available for unfamiliar or unusual requests.

Benefits

For customers:

  • Fewer tokens spent on repeated schema discovery and query construction.

  • Faster responses and fewer sequential tool calls.

  • More consistent results across different AI models and agents.

  • Fewer errors involving incorrect field names, relationships, or query structures.

  • Easier onboarding of new agents without maintaining separate workspace instructions for each AI platform.

For Fibery:

  • Potentially fewer redundant schema requests and intermediary API calls.

  • More predictable, optimized API access.

  • Less repetitive orchestration for Fibery-hosted agents.

  • A stronger position as the operational data platform for companies using multiple AI agents and models.

There is also a potential security benefit. Instead of giving an agent broad access to generic create/update tools, administrators could expose narrowly defined operations with specified inputs and permissions. These tools should still enforce the requesting user’s underlying Fibery permissions.

Relationship to Existing MCP Capabilities

I recognize that Fibery already has granular schema discovery tools and execute_code, which can consolidate multiple MCP operations. Those are valuable improvements.

What I’m proposing is the next step: define an operation once, persist it as part of the workspace configuration, and make it directly callable by any authorized MCP client.

An agent should not have to regenerate the same JavaScript, rediscover the same relationships, or reproduce the same query logic each time it performs a routine business operation.

The Broader Opportunity

As companies deploy multiple AI models and agents, the inefficiency of repeatedly teaching each one how the company operates becomes increasingly significant.

Fibery already holds the structured ontology of the business. It seems natural for Fibery to expose not only the underlying data and generic operations, but also reusable, workspace-specific capabilities derived from that ontology.

In short: Could Fibery let us turn our established ontology and common workflows into native, reusable MCP tools, so AI agents can execute known operations directly instead of continually rediscovering how our workspace works?