Dify MCP for AI. Test, debug, and manage complex AI workflows.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Dify MCP connects your AI agent directly to Dify's backend services. It lets your agent send chat messages, retrieve conversation history, manage files, audit app settings, and submit performance feedback—all without leaving the conversational interface.
Use this when you need an LLM application client to run complex, structured workflows against a dedicated AI platform.
What your AI can do
Chat
Sends an explicit text message into the Dify agent for immediate action or response.
List conversations
Gets a list of recent conversations associated with your Dify project for review.
List messages
Retrieves all the historical messages within a specific conversation thread.
Your agent sends specific chat messages directly into the Dify environment.
The agent can list past interactions and retrieve detailed message logs for auditing purposes.
You can pass local binaries to the agent, which uploads them as attachments within Dify.
The agent checks and reports on the current configuration limits of the referenced Dify workspace.
You can give a 'like' or 'dislike' to any message, helping track the AI’s overall performance.
Ask an AI about this
Waiting for input…
Dify with 6 Tools
These tools allow your agent to perform core lifecycle management tasks: chatting, listing history, uploading files, auditing settings, and providing feedback.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Dify on VinkiusChat
Sends an explicit text message into the Dify agent for immediate action or response.
List Conversations
Gets a list of recent conversations associated with your Dify project for review.
List Messages
Retrieves all the historical messages within a specific conversation thread.
Get Parameters
Retrieves and reports on the current configuration limits set within your Dify...
Upload File
Sends a local file or binary data to Dify for secure ingestion and processing by the...
Feedback
Submits a 'like' or 'dislike' rating to track the performance of a specific message.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
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 Dify, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ 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
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Dify. 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 connection provides 6 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Today, tracking agent activity means jumping between dashboards.
Right now, if an agent fails a complex task, you have to manually jump through multiple tabs: the conversation log, the file attachment viewer, and the settings panel. You copy-paste message IDs into a spreadsheet just to track who said what, when, and why it failed.
With this MCP, your agent handles that coordination for you. It brings all those disparate views together—the full history via `list_messages`, the file context using `upload_file`, and even the system limits via `get_parameters`—all inside one conversational stream.
Using the Dify MCP gives you complete control over message tracking.
Manual debugging involves guessing which conversation ID is correct, then having to copy out hundreds of lines of text just to find the moment the agent went off-script. It's tedious and error-prone.
Now, you simply ask your agent to run `list_messages` for a given thread. The full array of historical interactions appears instantly in your client, letting you pinpoint exactly where the failure occurred without leaving the chat.
What your AI can actually do with this
This MCP hands your AI agent full control over its operational context within Dify. Instead of just having a single chat window, your agent can now execute multi-step tasks that mimic real software development pipelines. It tracks conversations by listing historical data and analyzing message arrays to pinpoint exactly what was discussed.
You can also securely upload files for the agent to process or check the app's structural limits using get_parameters. This gives developers a clear path to test and refine their LLM applications without needing external API calls. When you connect it via Vinkius, your agent gains access to this entire suite of Dify tools through natural conversation.
019d7585-d0d5-7363-a535-6285076840d8 Here's how it actually works
The bottom line is that you treat complex API calls like simple conversation commands.
Subscribe to this MCP and provide your Dify API URL and Application-specific API Key.
Your agent uses natural language prompts to trigger specific functions, like asking it to list recent conversations or upload a document.
The MCP executes the tool call on the Dify backend and returns structured data back to your AI client.
Who is this actually for?
AI developers need this when they want a full-stack testing environment. It's for the person who has built an agent but needs to test it against real, structured data and monitor its performance in depth. If you’re constantly copy-pasting logs or calling out to separate monitoring dashboards, this is for you.
Testing a new RAG pipeline requires running list_conversations to get context and then using upload_file to test document ingestion.
Needs the agent to manage ongoing tasks, like sending messages via chat, or checking if certain parameters are valid using get_parameters.
Uses this to monitor product performance by submitting feedback using feedback after a test run, verifying user satisfaction metrics.
What Changes When You Connect
Instead of manually checking logs, you can use list_messages to pull the full conversation history directly into your agent's context for review.
You don’t have to leave your chat client to test file handling. Just prompt the agent, and it uses upload_file to securely ingest local binaries for testing.
Monitoring performance is simple: after a session, use feedback to submit ratings, feeding valuable data back into Dify's CRM environment automatically.
Need to verify constraints? get_parameters gives you immediate access to the structural limits of your workspace without needing to consult separate documentation pages.
You can track an agent’s entire lifecycle—from initial setup parameters via list_conversations to final performance ratings using feedback.
See it in action
Auditing a customer support interaction
A team lead needs to review why an agent provided bad advice. They ask their agent to run list_conversations first, then select the relevant thread. Finally, they use list_messages to get every single message and track down which prompt caused the error.
Testing a new knowledge base feature
A developer wants to see how well their agent handles PDFs. They first run get_parameters to check the file constraints, then use upload_file to feed in a test PDF, and finally chat with it using the chat tool.
Analyzing overall product health
The Product team wants an aggregate view of agent performance. They run list_conversations, spot several threads that seem problematic, and then use feedback to submit 'dislikes' on the worst messages.
Debugging a complex multi-step workflow
An engineer notices an agent is failing. They ask the agent to list all recent conversations using list_conversations, pinpoint the problematic ID, and then use list_messages on that specific thread for deep debugging.
The honest tradeoffs
Treating it like a simple message board
Just pasting a massive block of text into the chat, hoping the agent figures out what to do with all that data.
Don't just chat. Use upload_file first if you have documents. If you need context, run list_messages or list_conversations so the agent knows exactly which data set it should focus on.
Ignoring system limitations
The agent fails when trying to process a large file because the developer never checked the constraints.
Always run get_parameters before uploading big assets. This confirms the maximum size or format limits of your Dify workspace.
Losing track of history
The agent forgets what was discussed 20 messages ago because it only looks at the last few turns.
When debugging, call list_messages to explicitly retrieve and feed back the full conversation array. You can't rely on memory alone.
When It Fits, When It Doesn't
Use this MCP if your goal is deep-dive agent testing—you need structured control over inputs (files, parameters) and outputs (history, feedback). If you primarily just want to send short announcements or run simple Q&A sessions against a single knowledge base, this might be overkill. Don't use it if all you need is basic chat interaction; the standard chat tool will suffice. You only need this level of control when your workflow requires auditing past interactions (use list_messages), validating setup rules (get_parameters), or actively managing performance metrics (feedback).
Questions you might have
How do I check my Dify app limits using the `get_parameters` tool? +
You ask your agent to 'Check the structural parameters for this workspace.' The agent will then call get_parameters and return a report detailing the global constraints you've set up.
Can I use the `upload_file` tool with different file types? +
Yes, the tool is designed to securely transmit local binaries. The agent handles the ingestion of various types, though checking parameters first can confirm supported formats.
How does the `feedback` tool actually improve my Dify agent? +
Using feedback submits explicit message-level data (like/dislike) that is used by Dify to track performance metrics and identify areas where your agent needs retraining or improvement.
`list_conversations` vs. `list_messages`: what's the difference? +
Use list_conversations first; it gives you a high-level overview of recent chat sessions and their IDs. Then, if you need details, use list_messages with that ID to get the full thread content.
What credentials do I need to use the Dify MCP tools? +
You must subscribe to this MCP and provide your specific Dify API URL and an Application-specific API Key. These keys are found within your Dify App's API Access settings.
How can I get the full, structured message history of a conversation using `list_messages`? +
It retrieves detailed arrays that map every interaction in a conversation. These listings include timestamps, roles (user or agent), and the specific content for each historical message.
If I need to send a complex prompt structure using `chat`, how does it work? +
The chat tool accepts explicit strings, allowing you to embed formatted text, markdown, or structured data directly into the agent's conversation flow. This ensures the agent receives exactly what you intend.
Does `list_conversations` tell me about files attached to a specific dialogue? +
Yes, it extracts array vectors that represent company-wide conversation listings. These structures often contain pointers or references to attachments made during the recorded discussions.
Can my agent interact with a specific Dify application via chat? +
Yes. When you provide the Application API Key, the agent uses the 'chat' mutation to send your query directly to that Dify agent. It returns the AI response within your current chat context, allowing for seamless integration.
How do I retrieve the conversation history from my Dify project? +
Use the 'list_conversations' tool. Your agent will pull the explicitly attached array vectors representing your conversation listing. You can then use 'list_messages' with a specific ID to see the detailed interactions.
Can I upload files to my Dify agents through this server? +
Absolutely. The 'upload_file' tool allows you to transmit local binaries securely. The agent maps these files internally against standard Dify attachments, making them available for your Dify agents to process.
We've already built the connector for Dify. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 6 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.