Dify MCP. Manage conversations, debug agents, and upload files via chat.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Dify. Send chat messages, track conversation history, and manage LLM app parameters directly from any AI agent. This server lets your AI client interact with your Dify.ai backend to orchestrate agentic workflows, upload files, and audit message performance.
It's full control over your LLM application development, right through natural conversation.
What your AI agents can do
Chat
Sends a message to the Dify agent and continues the conversation.
Feedback
Sends a 'like' or 'dislike' rating for a specific message to track agent performance.
Get parameters
Retrieves the configuration limits and settings for the Dify application.
Your agent sends a message and begins an explicit conversation thread with the Dify agent.
Your agent retrieves a list of recent, company-wide conversations from your Dify project.
Your agent lists all messages within a specific, existing conversation thread.
Your agent reads the global configuration limits and parameters set for the Dify application.
Your agent sends local binary files to the Dify backend for secure attachment and processing.
Your agent submits a 'like' or 'dislike' to a message, improving the agent's performance tracking data.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Dify MCP Server: 6 Tools for Agent Workflows
Use these six tools to control Dify.ai from your chat client. You can chat, list conversations, check parameters, upload files, and audit performance.
019d7585chat
Sends a message to the Dify agent and continues the conversation.
019d7585feedback
Sends a 'like' or 'dislike' rating for a specific message to track agent performance.
019d7585get parameters
Retrieves the configuration limits and settings for the Dify application.
019d7585list conversations
Retrieves a list of conversation IDs and summaries from your Dify project.
019d7585list messages
Retrieves all messages that occurred within a specified conversation ID.
019d7585upload file
Sends a local file to Dify and attaches it to the current conversation thread.
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 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
Listen up. This server lets your AI client talk directly to your Dify backend, giving you total control over how you build and manage those big LLM apps. You'll use it to run agentic workflows and handle stuff like file uploads and performance checks, all through simple conversation.
Your agent can chat a message to the Dify agent, keeping the conversation going. You can list_conversations to pull a list of company-wide conversation IDs and summaries from your Dify project. Need to see what happened in a specific chat? Use list_messages to pull every message that occurred in a given conversation thread.
You can get_parameters to read the global configuration limits and settings set for the Dify application. If you gotta attach a local file, upload_file sends that binary to Dify for secure attachment. You can also feedback by sending a 'like' or 'dislike' rating for a message, which tracks how well the agent is performing.
When your agent hits these tools, it's getting real control over your Dify workspace. It's not just sending messages; it's managing the whole lifecycle, from starting a chat to checking the limits and giving performance data. This means you can build and debug complex agent flows without ever leaving your chat client.
How Dify MCP Works
- 1 First, you subscribe to the Dify MCP Server and provide your Dify API URL and App API Key.
- 2 Your AI client calls the necessary tool (e.g.,
list_conversations) and passes the required parameters (like a user ID or date range). - 3 The Dify server processes the request, executes the tool logic against your Dify workspace, and returns the structured data to your AI client.
The bottom line is, your agent acts as a secure bridge, letting your AI client talk to your Dify application's API endpoints through natural conversation.
Who Is Dify MCP For?
This server is for the AI developer who needs to test and debug agents without leaving their coding environment. It's for the automation engineer who needs to manage complex conversations and upload attachments using plain language. If you're on a product team monitoring agent performance, this saves you from clicking through dozens of dashboards.
Tests Dify agents and RAG pipelines directly within the chat client, debugging workflows and verifying application parameters in real-time.
Manages conversation threads, lists message history, and uploads attachments to Dify apps using natural language commands.
Monitors agent performance by submitting message-level feedback and verifying application parameters before a public release.
What Changes When You Connect
- Audit performance with
feedback: Instead of guessing why an agent failed, usefeedbackto submit likes/dislikes on specific messages. This builds a record used for tracking agent performance and improving your internal CRM. - Manage full chat history with
list_conversationsandlist_messages: You don't have to open the web UI. Your agent lists all conversations, then pulls specific message arrays, keeping the entire history visible and accessible via natural language calls. - Control the environment with
get_parameters: Need to know if your agent hit a usage limit?get_parameterspulls the global constraints and configuration limits of the Dify workspace so you can debug the boundaries of the agent's operation. - Ingest data easily with
upload_file: Stop manually attaching files. Your agent handles the process of taking a local binary file and transmitting it securely to Dify, attaching it to the conversation context automatically. - Keep the conversation flowing with
chat: This tool lets your agent send messages directly to the Dify backend, maintaining the conversation state without needing to switch tools or contexts. - Build reliable pipelines: By combining
list_conversations(to find the context) withlist_messages(to get the content) andchat(to continue the flow), you create a reliable, multi-step agent pipeline.
Real-World Use Cases
Debugging a flaky RAG pipeline
The AI developer notices the agent is giving vague answers. Instead of checking logs on the Dify web interface, they ask their agent: 'Check the parameters and list the last 10 messages for user X.' The agent uses get_parameters and list_messages to pull the necessary context, showing the developer exactly where the constraint or data gap is.
Tracking customer support outcomes
The product manager needs to know if the agent's advice was helpful. They prompt their agent: 'Give a 'dislike' to the advice given in the last message.' The agent calls the feedback tool, recording the negative input that helps the team track and improve the agent's performance.
Handling an urgent client file upload
An automation engineer receives a client document and needs the agent to process it immediately. They instruct the agent: 'Upload this Q3 report and start a new conversation.' The agent uses upload_file to ingest the binary data and then uses chat to initiate the next step of the workflow.
Reviewing a multi-day project discussion
A team lead needs a summary of all discussions related to Project Phoenix. They ask their agent: 'List all conversations for Project Phoenix.' The agent uses list_conversations to get the IDs, and then calls list_messages on the relevant ID to provide the full historical context.
The Tradeoffs
Treating the agent like a search bar
Asking the agent, 'Tell me about the project and its history.' The agent might give a generic answer, but the user has no way to verify the source or the full conversation history.
→
To get verifiable history, first use list_conversations to identify the correct thread ID. Then, use list_messages with that ID. Finally, use chat to ask for a summary, ensuring all data is pulled from the Dify backend.
Forgetting to check constraints
The agent fails because the Dify app hits an unexpected rate limit, but the user has no way of knowing why the failure occurred.
→
Before running a complex workflow, use get_parameters to check the global application limits. This shows the user the hard constraints of the Dify workspace, preventing unexpected failures.
Overloading the chat tool
Trying to pass a huge file and a complex query in a single chat message, hoping the agent handles both the upload and the context retrieval.
→
Separate the tasks. First, use upload_file to handle the binary data transfer. Once the upload is confirmed, use chat or list_messages to reference the file and ask the specific question.
When It Fits, When It Doesn't
Use this if you need to build a verifiable, stateful agent workflow around a Dify application. You need to confirm history (list_conversations, list_messages), manage data ingestion (upload_file), or audit performance (feedback).
Don't use this if your goal is just to chat with a general knowledge model without needing to interact with a specific, managed Dify backend. For pure, stateless chat, a general LLM connection is enough. You need the Dify connection to manage the state, the parameters, and the file attachments.
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 server provides 6 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Debugging an agent's conversation flow shouldn't require jumping between dashboards.
Today, if your agent gives a weird answer, you have to copy the conversation ID from the Dify web UI, open a separate tab, and manually check the message logs. Then, if you need to verify the app's limits, you have to navigate to a different section entirely. It's a tedious, three-step process with three different interfaces.
With the Dify MCP Server, you tell your agent, 'Show me the history and the constraints.' The agent uses `list_conversations` and `get_parameters` automatically. You get the full context and the hard limits—all in one chat window. It's immediate.
Dify MCP Server: Manage conversation data with `list_messages`.
Before, getting the full message history meant relying on pagination limits in the web interface, often missing key context points. You had to manually count pages and copy blocks of text.
Now, your agent uses `list_messages` to extract the complete message array for a given conversation. You get the full, clean data payload immediately, letting your agent summarize or act on the entire history, not just the visible snippet.
Common Questions About Dify MCP
How do I use the `list_conversations` tool with Dify? +
The list_conversations tool retrieves a list of conversation IDs and summaries from your Dify project. You need to provide the necessary filters (like a user ID or date range) to get the list you want.
Can I use `upload_file` to attach a file to a specific conversation? +
Yes, the upload_file tool handles the transfer of local binaries and attaches them to the current conversation context. The agent manages linking the file to the correct conversation ID.
What does the `get_parameters` tool do in Dify? +
The get_parameters tool reads the global configuration limits and parameters set for the Dify application. This is essential for checking the boundaries and limits of your agent.
Why should I use `feedback` instead of just chatting? +
Using the feedback tool submits a structured like or dislike rating. This action is recorded in Dify's backend, which helps track your agent's actual performance metrics outside of the chat log.
How do I get all messages in a conversation using `list_messages`? +
The list_messages tool pulls the full message array for a specific conversation ID. You must pass the correct conversation ID as a parameter for the tool to work.
How do I send a message using the `chat` tool? +
You send a chat message by providing the target agent name and the message content. The tool handles the API call, passing your prompt directly to the Dify backend. You don't need to manage conversation IDs manually; it just sends the message.
What is the best way to manage conversations using `list_conversations` and `list_messages`? +
First, use list_conversations to get a list of all relevant conversation IDs. Then, you pass a specific conversation ID to list_messages to pull the full message array for review. This two-step process ensures you get all the data you need.
Can I use `get_parameters` to check limits or constraints in my Dify app? +
Yes, get_parameters retrieves the configuration limits for your Dify workspace. This shows explicit constraints, like maximum file sizes or usage quotas, so your agent doesn't run into unexpected errors.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Qdrant
Empower your AI to interact directly with your Qdrant vector database — query clusters, perform similarity searches, and manage collections effortlessly.
OpenAI
Use GPT-4o, DALL-E 3, embeddings, fine-tuning, and moderation as tools inside your AI agent workflows.
HrFlow.ai
AI-powered talent acquisition API for parsing, matching, and reasoning.
You might also like
TzKT (Tezos Indexer & Explorer API)
Access real-time Tezos blockchain data — explore accounts, smart contracts, and transaction history directly from your AI agent.
Nifty (All-in-One Project Management)
Manage projects via Nifty — create tasks, track sprint milestones, and audit project portfolios.
Everfit Coaching
Equip your AI agent to manage coaching clients, track workout plans, and monitor performance via the Everfit API.