Verba MCP. Chat-Based Knowledge Graph Management
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Verba connects your private knowledge base directly to your AI agent. It lets you search proprietary documents and manage data using simple chat commands, bypassing traditional web UIs.
You can ingest new context, delete old records, or run deep RAG queries—all without leaving your IDE.
What your AI agents can do
Add knowledge document
Takes new document content and optional metadata JSON, then ingests it into the Verba knowledge base.
Delete knowledge document
Permanently removes a specified document from the knowledge base. This action cannot be undone.
Get document details
Retrieves the full content and associated metadata for one specific document ID.
The server runs perform_rag_query to answer questions using only the indexed content, providing source citations for every claim.
You can use add_knowledge_document to feed new text chunks into the knowledge base or delete_knowledge_document to permanently remove outdated information.
Run list_knowledge_documents to see every single file currently indexed, and use get_document_details to pull the full text and metadata for any specific ID.
The get_system_config tool pulls the current configuration details of your Verba instance directly into the chat.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Verba: 6 Tools for Document Management
These tools let you programmatically manage every aspect of your Verba knowledge base—from querying answers to deleting records.
019d761badd knowledge document
Takes new document content and optional metadata JSON, then ingests it into the Verba knowledge base.
019d761bdelete knowledge document
Permanently removes a specified document from the knowledge base. This action cannot be undone.
019d761bget document details
Retrieves the full content and associated metadata for one specific document ID.
019d761bget system config
Pulls the current operational configuration details of your Verba system.
019d761blist knowledge documents
Retrieves a list of all documents currently indexed in the knowledge base, showing their IDs and basic metadata.
019d761bperform rag query
Executes a RAG query against your entire knowledge base to return summarized answers with specific citations.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Verba, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Verba MCP Server: Managing Your Private Knowledge Base
The Verba server plugs your proprietary knowledge base right into your AI agent's workflow. You run deep Retrieval-Augmented Generation (RAG) and manage all your localized data using simple chat commands, sidestepping clunky web UIs entirely. It lets you search private documents, ingest new context, delete old records, or pull the system config—all without leaving your IDE.
Querying Proprietary Knowledge
When you need answers from your internal docs, you run perform_rag_query. This tool executes a RAG query across everything indexed in the Verba knowledge base. It doesn't guess; it pulls summaries and provides specific citations for every single claim it makes. You get an answer backed by verifiable source material, eliminating guesswork when dealing with complex corporate data.
Auditing Your Data Structure
You can audit exactly what's in the system before you use it. To see a comprehensive list of everything currently indexed, run list_knowledge_documents. This tool returns every file ID and basic metadata housed in your knowledge base. If you need more detail on one specific document, you pull its full content and associated metadata by using get_document_details with the relevant document ID.
Beyond listing files, you can diagnose the setup itself. Running get_system_config pulls the current operational configuration details of your Verba instance directly into the chat window. It's a quick way to verify which embedding model or other system parameters are currently active for your agent.
Managing and Modifying Content
The server gives you full control over what data the agent sees. You use add_knowledge_document when you need to feed new text chunks into the knowledge base, optionally including metadata JSON with that content. This tool lets you ingest fresh context on the fly.
Conversely, if information gets outdated or is no longer relevant, you run delete_knowledge_document. This permanently removes a specified document from the knowledge base, and it's critical to remember this action can't be undone. You've got total command over your data lifespan.
How It Works in Practice
The setup is straightforward: you point your agent—whether it's Claude or Cursor—at this Verba server endpoint. When you need an answer, you tell the agent to run perform_rag_query against a topic. The agent handles the API call and brings back a summarized, cited answer into your chat window. If you want to update context, you simply prompt it to use add_knowledge_document, feeding it the new text block right there in the conversation flow.
Need to check what's indexed? You just ask it to run list_knowledge_documents and get the list of IDs back.
This direct connection means your agent doesn't rely on a separate dashboard or web portal; you manage, query, and audit everything from one chat interface. It’s fast, it’s contained, and it keeps all that sensitive corporate data exactly where it should be: under your control.
How Verba MCP Works
- 1 First, you provide the server with your Verba API URL and API Key (if it needs authentication).
- 2 Next, you prompt your agent to run a specific tool—for example, telling it to
list_knowledge_documents. - 3 The agent executes the function call against the Verba backend and returns the structured result directly in your chat.
The bottom line is that your AI client speaks the language of the knowledge base API. You just talk to your agent, and it handles the rest of the plumbing.
Who Is Verba MCP For?
This is for the RAG developer who's tired of clicking through six different dashboards just to test a simple data flow. It’s for knowledge managers who need instant access to deep technical manuals, and any engineer who needs to validate system configurations without writing boilerplate setup scripts.
You use add_knowledge_document to test chunking strategies or delete chunks with delete_knowledge_document right inside your IDE, evaluating embedding fidelity immediately.
You query dense technical manuals using perform_rag_query and get verified text snippets instantly, citing the exact document ID so you know where the information came from.
You run get_system_config to verify that your local LLM connections and embedding models are running correctly before a major deployment.
What Changes When You Connect
- Query your knowledge base using
perform_rag_query. Instead of reading a wall of text, you get summarized answers with direct citations, so you always know the source. - Manage data on the fly. If a policy changes or a document is deprecated, use
delete_knowledge_documentto take it out immediately. No waiting for an admin panel update. - See exactly what’s indexed using
list_knowledge_documents. You can audit your entire knowledge base's contents in one chat command. - Deep-dive into any piece of data with
get_document_details. This tool lets you pull the full raw content and all metadata for a specific document ID, which is crucial for debugging RAG flows. - Verify server health instantly. Use
get_system_configto confirm your local LLM connections and embedding models are set up correctly—no need to jump into system logs.
Real-World Use Cases
Finding the source of truth for a policy change
A legal analyst needs to know what our company's current PTO policy is. Instead of searching five different SharePoint sites, they ask their agent: 'What is the latest PTO policy?' The agent runs perform_rag_query, which returns the summarized answer and cites the specific document ID from the HR manual.
Deprecating old product manuals
The engineering team just released a new version of the widget. They use add_knowledge_document to ingest the updated V3 guide, and then run delete_knowledge_document on the old V2 manual. This ensures their agent only cites current instructions.
Debugging an embedding failure
The developer suspects the wrong embedding model is active. They first run get_system_config to check the server's reported status. If it looks fine, they use list_knowledge_documents to confirm that all expected document IDs are present for testing.
Auditing a knowledge base before launch
A content strategist needs to make sure the agent has access to every required guideline. They run list_knowledge_documents to get the full inventory of indexed materials, confirming that no critical department manuals were missed.
The Tradeoffs
Asking a general question without citing sources
A user asks: 'What is our Q3 sales goal?' The agent replies with a generic summary that can't be verified against company data. This happens because the query didn't force citation.
→
Always wrap critical questions in perform_rag_query. This tool forces the agent to check your knowledge base and provides source citations, guaranteeing the answer comes from an actual document.
Trying to update a document by just pasting text
A user simply pastes new data into the chat. The system treats it as general context but doesn't properly index it or link it to existing knowledge, leading to lost information.
→
Use add_knowledge_document. This tool accepts both the content and optional metadata JSON, ensuring that when you feed new info, the agent correctly indexes it into the structured knowledge graph.
Relying on memory alone
The developer assumes the system remembers a document ID from an earlier conversation. If they start a new chat session, that context is lost.
→
Always verify document IDs by first running list_knowledge_documents to get the full inventory before attempting to use get_document_details or delete_knowledge_document.
When It Fits, When It Doesn't
Use this Verba MCP Server if your primary need is connecting a modern AI agent (like Claude or Cursor) directly to a private, structured repository of documents. It's ideal for RAG development and knowledge auditing because it gives you full control over the data lifecycle—from add_knowledge_document ingestion to targeted retrieval via perform_rag_query.
Don't use this if your primary workflow involves complex relationships between disparate entities (e.g., 'Show me all employees who worked on Project X and live within 10 miles of the main office'). For that, you need a dedicated semantic graph database toolset; Verba manages documents, not necessarily relationship graphs.
If your goal is simply to chat with an LLM generally, this server isn't needed. But if you want the AI to prove its answer by citing internal documents, this suite of tools is exactly what you need.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Verba. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 6 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Manually finding the source document sucks.
Today, when your agent gives an answer, you’re left guessing. You copy a snippet and then open 20 different tabs—the intranet, the shared drives, the old policy PDF—just to find the original file name and version number. It's click-intensive, slow, and often ends with you just ignoring the AI's answer because it can’t prove its source.
With Verba MCP, your agent doesn't guess. When it uses `perform_rag_query`, it runs against your indexed knowledge base and returns the answer *with* the document ID and citation right in the chat window. You get proof instantly.
Verba MCP Server: Managing Knowledge Content
The old way to update documentation was a multi-step nightmare: an engineer would have to open a web UI, upload the new file, wait for the indexer to process it, and then notify everyone that the change was live. It involved manual triggers and version control headaches.
Now, you manage it programmatically. Use `add_knowledge_document` directly via your agent to feed fresh context immediately. If a document is wrong? Just run `delete_knowledge_document`. You own the data pipeline end-to-end.
Common Questions About Verba MCP
How do I check if my Verba server is running correctly using Verba MCP Server? +
You use the get_system_config tool. This calls your agent to retrieve the current operational configuration, letting you see details like which embedding model it's utilizing or if connections are nominal.
Is there a way to delete an old document using Verba MCP Server? +
Yes, use delete_knowledge_document. Be careful with this one—it permanently removes the data and it's irreversible. You need the document ID to run this.
What is the difference between listing documents and getting details using Verba MCP Server? +
list_knowledge_documents gives you a summary catalog of all IDs in your base. get_document_details, however, retrieves the full content and metadata for one specific ID.
Can I add documents without manually uploading them? +
Yes, use add_knowledge_document. You supply both the content text and any required metadata JSON structure directly through your agent's prompt to ingest it into the knowledge base.
How does I use the perform_rag_query tool to get source citations? +
The perform_rag_query tool returns summarized answers directly tied to their sources. It doesn't just give a general answer; it provides document IDs and confidence scores, so you know exactly where the information came from.
When using add_knowledge_document, can I include metadata besides the content? +
Yes, you can. The add_knowledge_document tool allows an optional metadata JSON payload. This means you can tag documents with context—like department or date—which helps filter results later on.
What is the best way to check if a document ID exists before using get_document_details? +
First, run list_knowledge_documents to see all indexed IDs. Then, pass that specific ID into get_document_details. This confirms the document's full content and metadata without guessing an ID.
If I use get_system_config, what information about my Verba environment do I receive? +
get_system_config pulls the current operational status of your entire instance. It shows details on your active embedding model and confirms if all local LLM connections are properly established.
Can I query my local Verba instance directly through Cursor? +
Yes! Once you configure VERBA_API_URL to point to http://localhost:8000 (or your host port), you can prompt your AI assistant to execute rigorous perform_rag_query instructions without ever breaking your developer focus.
How do I insert fresh text data into Verba completely using conversational chat? +
Provide the agent with your desired context directly. For example: Add this chunk of markdown as a new document to Verba: '# Title Content...'. The agent leverages addDocumentTool, serializes the payload, and commits it into Verba's vector store immutably.
Are the query answers backed by citations from its embedded documents? +
Absolutely. That's the primary benefit of the integration. When you run perform_rag_query, Verba utilizes Weaviate's hybrid search mechanics. The output explicitly includes natural language synthesis backed by the unique document IDs and snippet texts it referenced.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
CHATFLY
Manage AI chatbots and knowledge bases via CHATFLY — train bots on custom data and track conversations directly from any AI agent.
Cohere
Access Cohere AI models via API — chat with Command models, generate embeddings, rerank documents and tokenize text from any AI agent.
Chatsistant
Deploy white-label AI assistants for your clients with custom branding, knowledge bases, and conversation analytics.
You might also like
GenerateBanners
Create professional ad banners and social media graphics automatically with templates that match your brand guidelines.
Glow Loyalty
Manage loyalty members, track point balances, and oversee rewards via AI agents with Glow Loyalty.
Erply ERP & POS
Equip your AI agent to manage retail products, track sales invoices, and monitor inventory via the Erply API.