Dify.AI SDK MCP for AI. Orchestrate complex LLM workflows via API calls.

Q: How do I check my chat history using getconversations?

You call getconversations to pull a list of recent conversation IDs and titles. This provides the necessary context before you use getconversationmessages to fetch the detailed content.

Q: Can I stop an AI response if it's too long?

Yes, that's where stopchatgeneration comes in. It only works when the chat message is streaming, allowing your agent to interrupt the generation process mid-stream.

Q: What if I need to analyze a PDF file?

First, you must use uploadfile. This function handles uploading content from a URL so that subsequent tools, like workflow execution, can access and understand the document's contents.

Q: Does runworkflow need parameters?

Yes. Before running any complex task, you should use getworkflowparameters to see exactly which inputs your workflow requires. This prevents runtime errors.

Q: If I run into issues with my logic, how do I handle failures using runworkflow?

The response from runworkflow includes detailed status codes and execution logs. Your agent reads these logs to pinpoint the failure point, allowing you to implement specific retry or fallback logic.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

The Dify.AI SDK lets your agent programmatically interact with a specialized AI platform. You can send messages to published chatbots, run multi-step workflows using dynamic parameters, fetch historical chat records, and even submit model feedback for tuning.

This gives you total control over the lifecycle of an AI application.

What your AI can do

Delete conversation

Removes an entire conversation history from the platform.

Submit feedback

Records user feedback (like or dislike) on an agent's message for model improvement.

Get suggested questions

Returns suggested follow-up questions after an agent sends a message, helping guide the conversation.

+ 11 more capabilities included

Manage Chat Interactions

Send new messages to a chatbot and retrieve past message threads for context.

Execute Background Workflows

Trigger complex, multi-step AI processes using specific data parameters.

Maintain Conversation State

List, rename, or delete conversation histories to keep records clean and organized.

Improve Model Tuning

Submit user feedback (like/dislike) directly to the platform to improve model accuracy over time.

Process External Data

Upload files via URL, allowing the AI agent to perform multimodal understanding on documents or images.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Dify.AI SDK: 14 Tools for AI Ops

These tools allow you to fully control the lifecycle of any Dify-powered application—from simple messages to complex, multi-step background workflows.

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.AI SDK on Vinkius

Delete Conversation

Removes an entire conversation history from the platform.

Submit Feedback

Records user feedback (like or dislike) on an agent's message for model improvement.

Get Suggested Questions

Returns suggested follow-up questions after an agent sends a message, helping guide...

Chat Message

Sends text to a specific Dify Application and gets an immediate response.

Get App Meta

Retrieves basic configuration details about a Dify application.

Get Conversation Messages

Fetches all the message content from a specific chat thread.

Get Conversations

Lists the most recent chats associated with your account.

Get Workflow Info

Gets general information and status details for a Dify workflow application.

Get Workflow Parameters

Retrieves the list of required inputs (parameters) needed to run a specific workflow.

Rename Conversation

Changes the title of an existing conversation thread.

Run Workflow

Executes a complex, parameterized Dify Workflow application to complete a task.

Send Completion

Sends a request to get the full generated text output from an AI model completion app.

Stop Chat Generation

Halts a chat response that is currently streaming in real-time.

Upload File

Uploads a file using a URL so the AI can analyze its content, supporting multimodal...

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.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The Dify.AI SDK integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "difyai-sdk": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Dify.AI SDK tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"difyai-sdk": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

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

Start building

Make Your AI Do More

Start with Dify.AI SDK, 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.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

Your data is protected. See how we built it.

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 14 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Manually tracking and cleaning up AI interactions is a huge time sink.

Right now, managing conversation history means jumping between tabs: checking the chat log, finding the right user ID, manually copying titles to rename things, and then keeping track of which messages were actually part of the critical thread. It's a series of clicks and copy-pastes that breaks your focus.

With this MCP, you let your agent handle that entire process. You simply tell it to list recent chats using `get_conversations`, then ask it to fetch the full history for any specific chat via `get_conversation_messages`. The system manages the data retrieval and organization automatically.

Running complex, multi-stage tasks with Dify.AI SDK MCP

Without this toolset, if you needed to process a document and then generate a summary using that summary in another service, you'd have to write brittle, interconnected code blocks handling data passing manually. You're always one API key away from failure.

Now, you define the entire sequence inside Dify and trigger it all with a single call to `run_workflow`. Your agent passes clean JSON parameters, executes the whole chain, and gets the final output without any manual orchestration needed on your end.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Building complex applications often means more than just sending a prompt. It requires state management, background processing, and continuous improvement loops. With this MCP, your agent connects directly to Dify's core platform, giving it access to dozens of specialized functions. You can trigger multi-step workflows with precise JSON inputs, ensuring the AI executes logic beyond simple conversation.

Need to track a user's journey? Use the tools here to retrieve entire conversation histories or simply list recent activity. The ability to manage chat sessions and even submit 'like/dislike' ratings means you can build complete agent pipelines—from initial query through execution, all the way to model refinement. Accessing this via Vinkius means your AI client handles the connection; you just tell it what needs to happen.

Built · Hosted · Managed by Vinkius Dify.AI SDK - Orchestrate LLM Workflows

Server ID 019d842e-1d27-71f1-b648-724f9078ae2b

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Here's how it actually works

The bottom line is this: you pass structured instructions to your agent client, and the MCP handles the complex API calls required to make those instructions happen in Dify.AI.

First, your developer client needs an API key and a base URL for Dify.AI.

Next, you instruct your agent to call the necessary function, like run_workflow, providing all required parameters (e.g., workflow ID, input JSON).

The MCP executes the request, returning data—whether it's a chat response, a list of conversations, or confirmation that the process ran successfully.

What Changes When You Connect

You gain granular control over conversation state, allowing your agent to use get_conversations and get_conversation_messages to build context-aware interactions.

Instead of relying on single prompts, you can trigger multi-step logic by calling run_workflow, passing structured data parameters to achieve specific business outcomes.

The ability to manage the lifecycle is key. Use rename_conversation or delete_conversation when cleanup or record maintenance becomes necessary.

For model quality assurance, submit_feedback lets your application automatically capture user sentiment, feeding that data back into the AI training pipeline.

Multimodality is built-in. The upload_file tool means your agent doesn't just read text; it can analyze documents or images you link to.

See it in action

01 01

Analyzing User Support Tickets

A support engineer needs the system to process a user-uploaded PDF (via upload_file) and then run that data through a specialized internal knowledge base workflow (using run_workflow). The agent reads the file, executes the logic, and returns a summarized action plan.

02 02

Building Stateful Chatbots

A financial service bot needs to remember details from earlier in the chat. It first calls get_conversations to confirm the user's identity, then uses chat_message for the main interaction, and finally uses get_suggested_questions to guide them to the next logical step.

03 03

Automating Model Improvement

The product team wants to track how often users complain. After a chat exchange, the agent automatically prompts the user and then executes submit_feedback, recording whether the response was helpful or not for later tuning.

04 04

Background Data Processing

A data pipeline needs to process a large dataset without waiting for a live chat. The system triggers a dedicated workflow using run_workflow with parameters like 'dataset_id' and 'processing_date', getting a final status report back.

The honest tradeoffs

Assuming simple text prompts are enough

Anti-pattern

Asking the agent to 'process this document and tell me what I need.' This vague request forces the agent into an unstructured chat response, which is hard to automate.

The Fix

You must structure the process. First, use upload_file with the URL. Then, call run_workflow, passing the file ID as a required parameter for the workflow to execute properly.

Ignoring conversation history

Anti-pattern

The agent responds to a user's follow-up question but fails to reference what was said three messages ago, making the response feel disconnected.

The Fix

Before responding, call get_conversation_messages to pull the full context. Pass that entire message array into your workflow parameters for accurate responses.

Trying to manage state manually

Anti-pattern

Having separate code blocks for listing chats and getting messages, which creates redundant logic and potential bugs.

The Fix

Group these calls logically. Use get_conversations first to list the IDs. Then, iterate through those IDs using get_conversation_messages in a structured loop.

When It Fits, When It Doesn't

Use this MCP if your application requires multi-step logic or state management beyond simple Q&A. You need programmatic control over conversations, such as tracking history (get_conversation_messages) or executing complex background tasks via run_workflow. Don't use this if you simply want a basic chatbot; for that, standard messaging APIs are enough. However, don't assume everything is covered by chat tools. If you need to analyze external files (PDFs, images), you must use the upload_file tool first to give your agent access to multimodal data.

Questions you might have

How do I check my chat history using get_conversations? +

You call get_conversations to pull a list of recent conversation IDs and titles. This provides the necessary context before you use get_conversation_messages to fetch the detailed content.

Can I stop an AI response if it's too long? +

Yes, that's where stop_chat_generation comes in. It only works when the chat message is streaming, allowing your agent to interrupt the generation process mid-stream.

What if I need to analyze a PDF file? +

First, you must use upload_file. This function handles uploading content from a URL so that subsequent tools, like workflow execution, can access and understand the document's contents.

Does run_workflow need parameters? +

Yes. Before running any complex task, you should use get_workflow_parameters to see exactly which inputs your workflow requires. This prevents runtime errors.

How do I set up my credentials when calling get_app_meta? +

Authentication requires an API key, which you must provide to your Vinkius client. The tool needs the Base URL and a valid API Key to successfully retrieve application configuration metadata.

If I run into issues with my logic, how do I handle failures using run_workflow? +

The response from run_workflow includes detailed status codes and execution logs. Your agent reads these logs to pinpoint the failure point, allowing you to implement specific retry or fallback logic.

When I use get_conversation_messages, how do I ensure I retrieve all necessary history? +

You must pass a conversation ID and optionally a time range. The tool retrieves the full message payload for that session, ensuring your agent has complete context beyond simple summaries.

Are there any rate limits when sending messages with chat_message? +

Yes, Dify enforces standard API rate limits based on your account tier. If you hit a limit, the client receives an HTTP 429 error code, prompting you to implement backoff logic.

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).

Connect to your AI in seconds.

Delete conversation

Submit feedback

Get suggested questions

Dify.AI SDK: 14 Tools for AI Ops

Make your AI actually useful.

Delete Conversation

Submit Feedback

Get Suggested Questions

Chat Message

Get App Meta

Get Conversation Messages

Get Conversations

Get Workflow Info

Get Workflow Parameters

Rename Conversation

Run Workflow

Send Completion

Stop Chat Generation

Upload File

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Manually tracking and cleaning up AI interactions is a huge time sink.

Running complex, multi-stage tasks with Dify.AI SDK MCP

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Analyzing User Support Tickets

Building Stateful Chatbots

Automating Model Improvement

Background Data Processing

The honest tradeoffs

Assuming simple text prompts are enough

Ignoring conversation history

Trying to manage state manually

When It Fits, When It Doesn't

Questions you might have