Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@blob-storage store this large dataset and return the UUID"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A lightweight MCP data broker that stores large binary payloads under a UUID, enabling MCP clients and agents to exchange massive results without flooding the LLM context window.
MCP Client / LLM Agent
│
│ tool call (large result)
▼
MCP Server ──store_blob──▶ Blob Storage Service ──▶ SQLite + local files
│ │
│ returns UUID │ retrieve_blob(uuid)
◀──────────────────────────────┘The agent only ever sees a UUID token — not the raw bytes.
Related MCP server: Forgetful
src/blob_storage/
├── __init__.py # package metadata
├── config.py # pydantic-settings (env / .env)
├── models.py # SQLAlchemy ORM + Pydantic schemas
├── database.py # async engine, session factory, init_db()
├── storage.py # StorageBackend ABC + LocalFileBackend
├── service.py # BlobService (orchestration)
├── api.py # FastAPI REST API
└── mcp_server.py # MCP server (HTTP Streamable, /mcp)
tests/
├── conftest.py # shared fixtures
├── test_api.py # API integration tests
└── test_service.py # service unit testsuv syncuv run blob-api # defaults from config / .env
uv run blob-api --host 0.0.0.0 --port 9000 # override at runtimeInteractive docs available at http://<host>:<port>/docs.
uv run blob-mcp # defaults: 0.0.0.0:8001
uv run blob-mcp --host 0.0.0.0 --port 9001The MCP endpoint is served at http://<host>:<port>/mcp.
Settings are read from environment variables or a .env file in the project root.
Variable | Default | Description |
|
| Directory for blob files |
|
| SQLAlchemy async DB URL |
|
| Default TTL — 90 days. Use |
|
| Max upload size (500 MB) |
|
| REST API bind address |
|
| REST API port |
|
| MCP server bind address |
|
| MCP server port |
|
| REST API URL used internally by the MCP server |
|
| How often the TTL cleanup job runs |
CLI flags (
--host,--port) take precedence over config/env for the respective server.
Method | Path | Description |
|
| Liveness check |
|
| Store a blob |
|
| Download a blob |
|
| Metadata only (no payload) |
|
| Delete a blob |
Pass metadata as custom request headers:
Header | Default | Description |
|
| MIME type of the payload |
| config default | Override TTL; |
| — | Free-form source identifier |
| — | JSON object for arbitrary labels |
curl -X POST http://localhost:8000/blobs \
-H "Content-Type: application/octet-stream" \
-H "X-Mime-Type: application/json" \
-H "X-Origin: my-mcp-server" \
--data-binary '{"key": "value"}'Response:
{
"uuid": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
"expires_at": "2026-05-30T16:42:07Z",
"size_bytes": 16
}The MCP server uses the Streamable HTTP transport. Configure your MCP host to connect over HTTP rather than spawning a subprocess:
{
"mcpServers": {
"blob-storage": {
"type": "http",
"url": "http://127.0.0.1:8001/mcp"
}
}
}Tool | Input | Output |
|
|
|
|
|
|
|
| metadata JSON |
|
|
|
All binary data is base64-encoded in MCP tool calls (MCP messages are JSON/text).
uv run pytest tests/ -vTo use S3 or MinIO in production, implement the StorageBackend abstract class in storage.py:
from blob_storage.storage import StorageBackend
class S3Backend(StorageBackend):
async def store(self, blob_uuid: str, data: bytes) -> None: ...
async def retrieve(self, blob_uuid: str) -> bytes: ...
async def delete(self, blob_uuid: str) -> None: ...Then inject it into BlobService and the _backend singleton in api.py.
This server cannot be deployed
Shared, governed long-term memory for AI agents across tools and sessions via MCP and REST.
Persistent file storage for AI agents via MCP and curl. Upload, download, and version files.
Cross-tool persistent memory and context for AI assistants over MCP.
Persistent memory for AI agents — log and recall conversation context over MCP.
