Dify.AI SDK MCP. Run complex AI workflows and manage chat history.
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.AI SDK connects your AI agent to Dify.AI, letting it execute complex LLM workflows, chat with specialized chatbots, and manage conversation history.
It's designed for developers who need to programmatically control multi-agent systems, submit model feedback, or trigger background AI tasks. With 14 tools, you can manage the full lifecycle of Dify applications, from running a workflow to deleting a chat thread.
What your AI agents can do
Chat message
Sends a message to a specified Dify Application chatbot.
Delete conversation
Removes an entire Dify conversation record.
Get app meta
Retrieves the basic configuration data for a Dify application.
Send messages to a Dify chatbot and track the conversation using the chat_message tool.
Run entire Dify workflows using run_workflow, passing dynamic JSON parameters to control the process.
Fetch, rename, or delete conversation records using tools like get_conversations and rename_conversation.
Submit user feedback (like/dislike) via submit_feedback to help fine-tune the Dify model.
Get the list of messages in a specific chat thread using get_conversation_messages.
Upload a file via URL using upload_file so the chatbot can analyze multimodal input.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
019d842echat message
Sends a message to a specified Dify Application chatbot.
019d842edelete conversation
Removes an entire Dify conversation record.
019d842eget app meta
Retrieves the basic configuration data for a Dify application.
019d842eget conversation messages
Fetches the full message history for a given conversation ID.
019d842eget conversations
Lists the most recent conversation threads associated with a user.
019d842eget suggested questions
Gets suggested follow-up questions after a chat response.
019d842eget workflow info
Retrieves basic details about a Dify workflow application.
019d842eget workflow parameters
Identifies and gets the required input parameters for a Dify workflow.
019d842erename conversation
Changes the display name of an existing Dify conversation.
019d842erun workflow
Executes a Dify Workflow application using defined inputs.
019d842esend completion
Sends a request to get the full generated text from a Dify completion app.
019d842estop chat generation
Pauses an ongoing message generation stream for chat mode.
019d842esubmit feedback
Sends a like or dislike rating for a specific chat message.
019d842eupload file
Uploads a file by URL to allow the chatbot to process multimodal content.
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.AI SDK, 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
You're hooking your agent up to Dify.AI, and it gives you a full set of tools to run anything that Dify can do. You can chat with specialized bots by using chat_message to send a message to a specific Dify chatbot. You'll also get suggested follow-up questions via get_suggested_questions after a response.
You can execute multi-step workflows by calling run_workflow and passing it the JSON parameters needed to control the process. You can get basic details on a workflow with get_workflow_info, or check what inputs a workflow requires using get_workflow_parameters. You can manage conversation threads by using get_conversations to list the most recent threads, or you can rename_conversation to change a thread's title.
You can also fetch the complete message history for a specific conversation ID using get_conversation_messages, or check the basic configuration data for an app with get_app_meta. If you need to delete a chat thread, you've got delete_conversation. You'll also get the ability to handle file uploads for context by uploading a file via URL using upload_file, letting the chatbot process multimodal content.
To improve the underlying model, you can submit user feedback (like or dislike) using submit_feedback for a chat message. The system lets you streamline the chat experience by sending a request to get the full generated text using send_completion, or by pausing an ongoing message generation stream with stop_chat_generation. You can also manage the content lifecycle by calling chat_message to send a message, or by using send_completion if you're working with a completion app.
You can also keep track of files by calling upload_file with a URL. You'll also get a way to check if an ongoing chat generation is happening with stop_chat_generation.
How Dify.AI SDK MCP Works
- 1 Publish your desired App (chatbot or workflow) on Dify and generate the necessary API Key.
- 2 Configure your Vinkius agent with the Dify Base URL and the API Key.
- 3 The agent calls the relevant tool (e.g.,
run_workflow) and passes the required parameters, executing the logic on Dify's server.
The bottom line is: your agent treats Dify.AI as an external service it controls, executing complex logic without needing to run anything locally.
Who Is Dify.AI SDK MCP For?
This is for the LLM developer or product team building sophisticated agent systems. If you're tired of building complex, multi-step logic inside your own app, this lets you offload the orchestration to Dify.AI. You need this when your agent needs to interact with specialized, pre-built AI applications or needs to manage conversation state outside of your main codebase.
Integrates Dify's specialized workflows into a larger agent system, letting the agent call Dify-specialized logic for specific tasks (e.g., data extraction, classification).
Builds and monitors user-facing AI features that require conversation history tracking and explicit model feedback loops (RLHF).
Manages the full lifecycle of AI services, from deploying the core workflow to programmatically auditing and deleting conversation records.
What Changes When You Connect
- Execute multi-step logic with
run_workflow. Instead of writing complex state machines, you simply trigger a pre-built Dify workflow, passing necessary parameters like user IDs or data payloads. This offloads the orchestration complexity. - Maintain full control over chat state. Use
get_conversationsto see a user's recent activity, andget_conversation_messagesto pull the full transcript for auditing or summarization. - Improve your model without retraining. The
submit_feedbacktool lets your agent capture user 'like/dislike' votes and send them back to Dify, making the model better over time. - Handle dynamic input. The
upload_filetool lets the chatbot process multimodal inputs—a user can upload a PDF link, and the agent uses that data as context for the chat. - Speed up development cycles. Instead of building every single chatbot feature from scratch, you connect to Dify's platform, giving your agent access to dozens of pre-built, specialized agents.
- Control the chat flow. The
stop_chat_generationtool is critical for streaming interfaces, allowing your agent to gracefully pause or manage real-time message generation.
Real-World Use Cases
Auditing user interactions
A compliance officer needs to track if a user followed a specific process. The agent first uses get_conversations to list all recent activity. Then, it calls get_conversation_messages for the relevant ID, pulling the full transcript. Finally, it uses rename_conversation to label the chat thread for internal record-keeping.
Automating content moderation
A platform needs to automatically improve its AI model. The agent detects a confusing chat response, prompts the user for feedback, and then uses submit_feedback to record the 'dislike' rating, improving the model for the next user interaction.
Triggering a complex business process
A user asks the chatbot to generate a financial report. The agent doesn't generate the report itself; it uses get_workflow_parameters to determine the required dates and departments, then calls run_workflow to execute the full, multi-step reporting process.
Processing external documents
A user sends a link to a new technical manual. The agent first uses upload_file to ingest the document via URL. It then sends a message using chat_message, asking the chatbot to summarize the key points of the uploaded document.
The Tradeoffs
Treating the chat as a simple text box
The developer just sends a raw string to the chatbot without checking the context. The agent only gets a generic response because it can't access the conversation's history or file context.
→
Before sending a message, the agent must first call get_conversations to find the correct thread ID, then use get_conversation_messages to pull the full history. Only then should it use chat_message to maintain context.
Over-engineering the workflow call
Trying to manually pass every single parameter into the run_workflow call, guessing the correct types and order, which inevitably fails when the Dify app updates.
→
First, call get_workflow_parameters to get the exact list and required types of inputs. Then, use that structured data to construct and execute the run_workflow call correctly.
Assuming synchronous completion
Waiting for a chatbot response to finish completely before proceeding, which kills the user experience and makes the agent feel slow.
→
If the response is streamed, use stop_chat_generation to manage the stream flow. If the response is a completion, use send_completion to ensure you get the full, final text chunk.
When It Fits, When It Doesn't
Use this SDK if your core problem is orchestrating specialized AI services. You need to connect your agent to a powerful, pre-built LLM application (Dify.AI) that handles the heavy lifting (e.g., running complex data pipelines or specialized chatbots). You must use this if you need to manage the lifecycle of the conversation, like tracking history (get_conversation_messages) or feeding back into the model (submit_feedback).
Don't use this if you just need a simple, stateless API call (e.g., a single lookup). In that case, a simpler, dedicated service connector might be better. If your goal is only to display a list of conversations, get_conversations is sufficient, but if you need to act on that list (like renaming it), you need the full SDK.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Dify.AI. 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 14 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Manual AI setup forces developers to build state machines from scratch.
Today, integrating an LLM means building a massive state machine in your own code. You have to write logic to check if the user has a history, fetch that history, check if the workflow parameters are correct, and then call the service. It's a mess of `if/else` blocks and boilerplate code.
With the Dify.AI SDK, you delegate that complexity. You simply use `get_conversation_messages` to get the history, and then `chat_message` to send the prompt. The agent handles the state management; you just call the tools.
Dify.AI SDK: Run complex workflows and manage chat history.
Before, triggering a multi-step task meant hardcoding every single step: calling the service, waiting for output X, using output X to call service Y, waiting for output Y, etc. It was brittle and couldn't adapt.
Now, you use `run_workflow`. You pass the initial parameters, and the complex, pre-built logic executes entirely on Dify.AI. Your agent just needs to call one tool and gets the final, structured output.
Common Questions About Dify.AI SDK MCP
How do I find out what parameters I need for `run_workflow`? +
Call the get_workflow_parameters tool. It returns the required input names, data types, and descriptions for the specific workflow you want to execute.
Can I use the Dify.AI SDK to track user feedback? +
Yes, use the submit_feedback tool. This sends a structured like/dislike rating for a specific message, which helps Dify improve its underlying model tuning.
What's the difference between `chat_message` and `run_workflow`? +
chat_message sends a simple message to a chat interface. run_workflow is for executing complex, multi-step background processes that require specific data inputs, like generating a full report.
How do I get the full text from a completion request? +
Use the send_completion tool. This ensures you receive the entire generated text, rather than just a partial or streamed segment.
How do I handle conversation history with `get_conversations` and `get_conversation_messages`? +
You can fetch conversation lists using get_conversations and then retrieve specific message history with get_conversation_messages. You'll need the conversation ID for the second call. This lets your agent maintain context across sessions.
What's the best way to send text completion using `send_completion`? +
To send a text completion request, use send_completion and provide the prompt text. It's designed to return the full generated text, making it easy to pipe the output into subsequent steps in your workflow.
If I want to rename a chat, should I use `rename_conversation`? +
Yes, rename_conversation handles renaming. You just need the conversation ID and the new name. This is useful for keeping track of specific topics or outcomes within a user's chat history.
How do I upload files for multimodal understanding using `upload_file`? +
upload_file allows you to pass a file URL. This is essential for giving the model context beyond pure text, letting your agent process images or other data types.
Does this work with self-hosted Dify? +
Yes, simply replace the Base URL credential with your own domain (e.g. https://dify.mycompany.com/v1).
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
DJI Developer
Orchestrate DJI drones and payloads — manage flight logs, monitor device health, and handle firmware updates directly from any AI agent.
BrioHR
Orchestrate BrioHR management — retrieve employee profiles, monitor leave, and integrate claim reports directly from any AI agent.
SITA Airport Reference API
Query global airport infrastructure data — IATA codes, terminals, gates, and reference metadata via AI.
You might also like
AniList GraphQL
Access the world's largest anime and manga database — search titles, characters, staff, and manage your personal lists via GraphQL.
Turso
Automate distributed database workflows via Turso — manage edge locations, organizations, and libSQL databases directly from any AI agent.
Track-POD
Optimize delivery routes, capture electronic proof of delivery, and track driver performance for logistics operations.