Repository navigation
Replies: 4 comments 1 reply
|
Hi @pmaojo, thanks for this, and for choosing to bring the Floci Studio work into Floci UI instead of keeping a parallel project. That means a lot. The plan and proposal look great. Go ahead with the order you suggested:
Sticking to the catalog row + schema + adapter model from About the MCP serverWe're still thinking about it. We need to define the structure first, and it should be a common MCP for all the clouds (AWS, Azure, GCP) rather than something AWS-specific or tied to the console. So let's hold off on that one for now. Once we have a clearer design we'll share it, and your experience with the Floci Studio MCP would be very valuable there. Looking forward to the first PR! CC: @fredpena |
|
@pmaojo I’ve been thinking more about your MCP proposal. What if we integrate MCP directly into the UI backend API? Since floci-ui-api already speaks the protocols for all four emulators, we could invoke the Floci endpoints directly from there. Let’s jump on a call to dig into this and brainstorm further. Are you already in the Floci Slack? |
|
Yes that sound a more straightforward strategy than my boto3 + others, by using the already existing API. Though I would then rename floci-ui to Floci Studio, or floci-lab, or workbench :) and then UI, API and MCP. A repo called UI sounds like a graphic interface (doesn´t it?) just a subjective idea. I am not on slack, yet, I will get in soon! thanks The possible tools are way too many tools to expose to an agent. For some tIme I have ben using a MCP with all the tools (AWS) to just end usign the Lambda and S3 tools... Here is the approach I followed. Obviously this next part is an extract made by AI: . Floci MCP: architecture and progressive tool discoveryOverview
The main architectural challenge is tool discoverability. Exposing hundreds of individual cloud operations as separate MCP tools increases context consumption and makes it harder for an LLM to choose the right one. Instead of registering every operation as an independent tool, the server combines four mechanisms:
Repository: https://github.com/pmaojo/floci-mcp-unofficial 1. High-level architectureflowchart TD
Agent["AI Agent<br/>Claude Code · Cursor · Codex"]
MCP["MCP Server<br/>floci_mcp.py"]
Registry["Toolset Registry<br/>Registers only enabled tools"]
Gateway["Generic Gateway<br/>Classify · Validate · Route"]
AWS["AWS Adapter<br/>boto3 / botocore"]
REST["Multicloud Adapters<br/>HTTP / REST"]
Backend["Local Backend<br/>AWS CLI · Docker Compose"]
AWSRuntime["Floci AWS<br/>localhost:4566"]
Azure["Floci Azure"]
GCP["Floci GCP"]
OCI["Floci OCI"]
Recipes["Local Docker Recipes"]
Agent <-->|"MCP over stdio"| MCP
MCP --> Registry
Registry --> Gateway
Gateway --> AWS
Gateway --> REST
Gateway --> Backend
AWS --> AWSRuntime
REST --> Azure
REST --> GCP
REST --> OCI
Backend --> Recipes
The MCP server exposes tools to AI agents but does not implement cloud emulation itself. It delegates to Floci's local runtimes and to execution backends:
2. The core problem: too many toolsAn MCP client discovers tools through their definitions: names, descriptions and input schemas. Registering a large number of similar tools increases context consumption and makes tool selection harder. The project addresses this with three complementary approaches:
flowchart TD
Task["User task"]
Strategy{"Access strategy"}
Curated["Curated toolsets<br/>Named cloud operations"]
Generic["Generic gateway<br/>5 tools"]
Code["Code gateway<br/>2 tools"]
Task --> Strategy
Strategy --> Curated
Strategy --> Generic
Strategy --> Code
Curated --> Activate["Enable required toolsets"]
Generic --> Discover["Search operation catalogue"]
Discover --> Describe["Inspect operation schema"]
Describe --> Execute["Execute read or write"]
Code --> Workflow["Chain operations<br/>and filter results"]
Activate --> Execute
Workflow --> Execute
The key distinction: the number of available cloud operations does not have to equal the number of tools registered with the MCP client. 3. Curated toolsetsThe server groups named tools into capability-based toolsets.
Toolsets determine which named tools are registered. They are configured at startup: # Default when FLOCI_TOOLSETS is unset: core, storage, messaging, compute
FLOCI_TOOLSETS=core,storage
# Register every toolset
FLOCI_TOOLSETS=all
# Remove every tool that changes state
FLOCI_READ_ONLY=1The server also supports dynamic activation through Two settings control dynamic activation: # Optional: cap which toolsets an agent may enable at runtime
FLOCI_TOOLSETS_ALLOWED=ops,marketplace
# Forbid switching toolsets altogether
FLOCI_TOOLSETS_ALLOWED=If The default configuration registers about 90 named tools (roughly 9K tokens). 4. Generic gateway: many operations, few toolsThe generic toolset is the main context-reduction mechanism. Instead of registering one MCP tool per AWS operation, it exposes five generic tools:
The AWS catalogue is generated from Example: sending an SQS messagesequenceDiagram
participant Agent as AI Agent
participant MCP as MCP Server
participant Catalog as Operation Catalogue
participant Gateway as Generic Gateway
participant Floci as Floci AWS
Agent->>MCP: search_operations("send a message to a queue")
MCP->>Catalog: Search matching operations
Catalog-->>MCP: sqs.SendMessage
MCP-->>Agent: Matching operation
Agent->>MCP: describe_operation(aws, sqs, SendMessage)
MCP-->>Agent: Parameters and required fields
Agent->>MCP: call_write(aws, sqs, SendMessage, params)
MCP->>Gateway: Classify and validate
Gateway->>Floci: Execute through boto3
Floci-->>Gateway: Operation result
Gateway-->>MCP: Result
MCP-->>Agent: Tool response
The model discovers the operation, inspects its parameters and executes it through the appropriate gateway. It never needs the S3, Lambda, DynamoDB or IAM tool definitions in its context to do this.
5. Retrieval-based tool discoveryThe project also provides
On the 40 tasks in
These numbers measure findability, not whether a language model completes the task successfully with the result. 6. Code gateway: execute workflows, not individual callsFor workflows that need several operations or produce large intermediate results, the server provides two tools:
These let a workflow chain operations and reduce the data before returning a smaller response to the model: buckets = aws("s3", "ListBuckets")["Buckets"]
topics = call("gcp", "pubsub", "ListTopics")
result = {
"bucket_count": len(buckets),
"topics": topics,
}The example illustrates the approach rather than a guaranteed signature for every adapter. Instead of sending each intermediate result through the conversation, the agent runs one workflow and receives a consolidated result.
7. Optional decision-model routingThe server also offers an optional flowchart TD
Task["User task"]
Model["Decision model"]
Scores["Toolset relevance<br/>probabilities"]
Policy["Confidence threshold<br/>and allowlist"]
Enable["Enable selected toolsets"]
Agent["Agent executes task"]
Task --> Model
Model --> Scores
Scores --> Policy
Policy --> Enable
Enable --> Agent
This strategy is:
It is an alternative routing mechanism, not a prerequisite for generic operation discovery. 8. Architecture and dependency boundariesThe
This separates cloud execution from MCP tool registration and keeps application logic testable with fake transports. 9. Recommended configurationsCompact tool surface with generic cloud access: FLOCI_TOOLSETS=generic,core uv run python floci_mcp.pyWorkflows that chain operations and process intermediate results: FLOCI_TOOLSETS=code,core uv run python floci_mcp.pyNamed, domain-specific tools: FLOCI_TOOLSETS=core,storage,messaging uv run python floci_mcp.pyEach configuration trades off explicit tool names, discoverability and context size. ConclusionThe project separates cloud capability from MCP tool exposure. Its context-reduction strategy combines:
The central principle:
|
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
Hi! I built Floci Studio, an unofficial community frontend for Floci, before Floci UI existed. Now that there is an official console, I'd rather put that effort here than keep a parallel project. Below are the features from Floci Studio that I think fit Floci UI's principles (real SDK contracts, no fake data, everything through
packages/api), each checked against what Floci already implements. I'd love to know which ones you'd accept before I open any PR.Fits the existing adapter + schema model
Floci already serves these APIs (see its
docs/services/), and as far as I can tell Floci UI doesn't use them yet:Scantoday. Floci implementsExecuteStatement, so the data explorer could get a query editor like the Azure SQL one.Scan) and import them back withBatchWriteItemin chunks of 25. Useful for moving fixtures between local runs.GetBucketCors/PutBucketCors/DeleteBucketCors, which Floci supports.CreateAutoScalingGroup,DescribeAutoScalingGroupsand friends, but the service isn't in Floci UI's catalog. Following AGENTS.md, it would be a catalog row, a schema and an adapter, with no frontend change.Needs your call first (they touch the layout or the scope)
GetResources,TagResources,UntagResources), which Floci implements.Proposal
If you agree, I'd start with 1 (PartiQL) as a small, self-contained PR, then 3, 2 and 4. For 5 to 7 I'd only do what you explicitly want.
Thanks for Floci and Floci UI!
All reactions