Loading ToolBench
Unified MCP proxy that aggregates all your MCP servers (STDIO, SSE, Streamable HTTP) into one powerful interface. Access any tool through a single connection, search across unified documents with built-in RAG, and receive notifications from any model.
This MCP server provides 29 tools with mostly clear naming and descriptions, but exhibits significant inconsistencies in schema quality, parameter documentation, and error handling guidance. The proxy pattern is well-executed for tools 1-2 (tool_call, get_tools), which enable dynamic tool discovery and invocation. Tools 3-29 (pluggedin_* suite) show strong descriptive effort but suffer from uneven schema definition, many parameters lack explicit type constraints, and output schemas are not documented. Security-critical concerns exist: the server accepts tool arguments as arbitrary objects without validation or sanitization, and error guidance is sparse. Naming is generally verb-first and clear (pluggedin_create_document, pluggedin_search_documents), but several tools bundle related concerns (e.g., pluggedin_memory_session_start/end + pluggedin_memory_observe blur session lifecycle and observation recording). Despite these gaps, the server demonstrates production intent: environment variable secret injection, permission gating via API keys, comprehensive notification/document/memory features, and Streamable HTTP support.
Retrieves the list of currently active and available proxied MCP tools managed by PluggedinMCP. Use this tool first to discover which tools (like 'github__create_issue', 'google_calendar__list_events', etc.) are available before attempting to call them with 'tool_call'. Requires a valid PluggedinMCP API key configured in the environment.
Ask questions and get AI-generated answers from your knowledge base. Returns structured JSON with answer, document sources, and metadata. For finding specific documents, use pluggedin_search_documents instead.
Rate community patterns to improve Collective Best Practices quality.
Query privacy-preserving patterns aggregated from the community (Collective Best Practices).
Delete clipboard entries by name, index, or clear all.
tool_call accepts 'arguments' as an arbitrary object (z.record(z.any())) with no validation, sanitization, or schema documentation. This is a security risk for prompt injection and command injection attacks. LLMs can pass malicious payloads (SQL, code, path traversal) that are forwarded to proxied tools without filtering.
No output schemas are documented for any tool. Descriptions state what tools return (e.g., 'Returns structured JSON with answer, document sources, and metadata'), but the actual response object structure is not specified. This forces LLMs to infer output shapes, increasing parsing errors and hallucination.
Many tools accept complex parameters (filters, metadata) as arbitrary objects without schema definition. Examples: pluggedin_list_documents.filters (type: object, no shape), pluggedin_create_document.metadata (type: object, no schema), pluggedin_clipboard_set.contentType (no enum or pattern). This leaves LLMs guessing at valid structures.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | C | 65 | 2026-07-28+ | v2 |
| 2026-03-09 | F | 41 | 1.27.1+ | v1 |
Get clipboard entries. Specify name or idx for a single entry, or omit both to list all entries with pagination.
List all clipboard entries with pagination support.
Pop a value from the clipboard stack (removes the last indexed entry).
Push a value onto the clipboard stack (indexed entry with auto-increment).
Set a clipboard entry by name (semantic key) or index (array-like). Named entries are upserted; indexed entries fail if index exists. Max 2MB per entry.
Create and save AI-generated documents to the user's library in Plugged.in (requires API key)
Delete a notification from the Plugged.in system
Triggers discovery of tools (and resources/templates) for configured MCP servers in the Pluggedin App (partial functionality without API key).
Retrieve a specific document's full content by ID. Use this after pluggedin_search_documents to get the complete content of documents you found. Set includeContent=true to get the full text.
List documents with filtering options from the user's library (requires API key)
List notifications from the Plugged.in system with optional filters for unread only and result limit
Mark a notification as done in the Plugged.in system
Get full details of a specific memory by ID.
Check your memory maturity score and personal development progress.
Record an observation or event during the current memory session.
Search memory for past observations and decisions using semantic search.
Search both personal memories and collective patterns filtered through Jungian archetypes (Shadow, Sage, Hero, Trickster).
End a memory session and generate a Z-report (session summary digest).
Start a new memory session for recording observations and decisions during a conversation.
Search for specific documents in your library. Returns document metadata (ID, title, snippet). To retrieve full content, use pluggedin_get_document with the returned document ID.
Send custom notifications through the Plugged.in system with optional email delivery. You can provide a custom title or let the system use a localized default.
Get started with Plugged.in MCP - shows setup instructions and API key configuration (no API key required)
Update or append to an existing AI-generated document (requires API key)
Executes a specific proxied MCP tool managed by PluggedinMCP. Use 'get_tools' first to find the correct 'tool_name' (e.g., 'github__create_issue'). Requires a valid PluggedinMCP API key configured in the environment. The API key is used implicitly by the server based on its environment configuration.
Error handling and recovery guidance is absent from all tool descriptions. No tool specifies what errors can occur, what they mean, how to recover, or what the LLM should do next. For example, pluggedin_get_document does not state what happens if documentId is invalid (404? 401? retry?). Pattern: recovery-guide.
Tools that require API keys (tool_call, get_tools, pluggedin_discover_tools, pluggedin_create_document, etc.) do not explicitly document the dependency in their descriptions. A user invoking these tools without a configured API key will receive a generic failure message rather than a clear 'API key missing' error.
Destructive operations (pluggedin_delete_notification, pluggedin_clipboard_delete, pluggedin_update_document with 'replace') lack confirmation/dry-run steps. An agent in a retry loop could inadvertently delete data multiple times. Pattern: confirmation-request.
Memory tools (pluggedin_memory_*) are named and designed as a session-oriented lifecycle (start → observe → end), but the session model is implicit. No tool documents what happens if observe() is called without a preceding start(), or what state persists between calls. This violates stateless protocol expectations.
Clipboard operations (pluggedin_clipboard_set, pluggedin_clipboard_get, pluggedin_clipboard_push) can be called with either 'name' or 'idx' parameters, but the semantics differ (upsert vs. insert). The parameter descriptions do not clearly state: (a) what happens if both are provided, (b) whether 'name' and 'idx' spaces are separate, and (c) what the default behavior is if neither is provided. This causes ambiguity for LLM decision-making.
pluggedin_memory_search_with_context and pluggedin_cbp_query both accept 'context_type' with enum values (proactive_warning, post_error, contextual), but the tool descriptions do not explain what these context types mean or when to use each. This forces the LLM to guess.
pluggedin_list_notifications and pluggedin_list_documents accept 'limit' but do not document pagination behavior. Do they return a cursor for subsequent calls? Do they return a total count? How do you know if there are more results? Forced to infer or experiment.