# Flowise MCP

> Flowise MCP connects your AI agent directly to a deployed FlowiseAI instance. You gain full command over low-code generative AI workflows. This means running predictions, listing complex chatflows and agentflows, checking execution history, or auditing the credentials used by your systems—all from conversation with any compatible client.

## Overview
- **Category:** ai-frontier
- **Price:** Free
- **Tags:** llm-orchestration, rag-pipelines, low-code, ai-agents, workflow-automation, chatflows

## Description

Need to debug an LLM pipeline without opening a dashboard? Flowise gives you that control. It connects your AI agent straight into your low-code generative AI development environment. Instead of relying on UI buttons, you just talk to your agent, and it handles the deep backend logic for you. You can list every chatflow or complex agent workflow you've built, run a test prediction on a specific flow instantly, and pull up precise logs of past executions. If something breaks in production, your agent won't just guess; it will use tools to retrieve detailed history, pinpointing exactly where the logic chain failed. Because Vinkius hosts this MCP, you can manage these complex AI workflows from any client that supports the catalog.

## Tools

### list_chatflows
Retrieves a list of every deployed chat flow name and ID.

### get_chatflow
Retrieves specific details about a single deployed chat flow.

### predict
Runs an immediate, simulated prediction by sending a user prompt to a specific chatflow.

### list_agentflows
Lists all available complex agent workflows (Agentflows) in the system.

### list_tools
Retrieves a list of custom tools and third-party integrations available to the agent.

### list_credentials
Enumerates all secure credentials components used by the Flowise platform.

### get_history
Fetches the detailed execution log for a given chat session or workflow ID.

## Prompt Examples

**Prompt:** 
```
Ask chatflow 'abc-123': 'Summarize this document: [Context]'
```

**Response:** 
```
Prediction initiated! I've sent your request to Flowise chatflow abc-123. The AI response is: 'Based on the provided context, the document outlines three primary growth strategies for the next fiscal year...'
```

**Prompt:** 
```
List all active chatflows in my instance
```

**Response:** 
```
Retrieving chatflows... I found 5 active flows: 'Customer Support Bot', 'RAG Knowledge Base', 'Legal Assistant', 'Lead Generator', and 'Developer Helper'. Which one would you like to explore?
```

**Prompt:** 
```
Show me the execution history for chatflow 'Legal-Assistant'
```

**Response:** 
```
Retrieving history... For 'Legal-Assistant' (ID: 789), I found 10 recent executions. Highlights include a query about 'GDPR compliance' and another regarding 'Contract Review'. Would you like the logs for any of these?
```

## Capabilities

### Check existing chatflows
List and get full details on every deployed conversational flow (Chatflow) within your Flowise instance.

### Examine agent logic
Access detailed descriptions of complex, multi-step AI task chains defined by Agentflows.

### Run real-time AI tests
Submit a user query to a specific chatflow and retrieve the generated AI response immediately.

### Audit execution logs
Pull detailed records of past interactions, allowing you to trace logic chains and monitor agent performance over time.

### Discover integrated tools
Retrieve a list of custom functions and third-party integrations configured in your Flowise environment.

## Use Cases

### Debugging a knowledge base bot
A data scientist notices the legal chatbot is giving outdated answers. Instead of manually reviewing database connections, they use their agent to run `get_history` for that chatflow and immediately see the query logs showing which external document failed to load.

### Verifying a new feature set
A product manager wants to confirm if the lead generation bot can access new CRM data. They prompt their agent, which uses `list_tools` and then runs a test prediction via `predict`, confirming the tool integration is live.

### Auditing security risks
An automation engineer needs to know what credentials are available for an upcoming audit. They use their agent to call `list_credentials` and get a full, enumerated list of every API key stored in the system.

### Checking complex logic flows
A development team is unsure if their new multi-step agent flow (Agentflow) works across all branches. They ask the agent to `list_agentflows`, select the target, and then manually trigger a test using `get_chatflow` details.

## Benefits

- You can test flows instantly. Use `predict` to submit a query to any chatflow, getting an immediate AI response without needing to manually set up test cases in the development UI.
- Debugging is simplified by accessing the execution record via `get_history`. This allows your agent to pull precise logs and pinpoint exactly where a complex logic chain failed months after the fact.
- Gain full architectural visibility. Instead of guessing, you can use `list_chatflows` and `list_agentflows` to see every deployed conversational asset in one place, confirming what's live in production.
- Manage integrations securely. Use `list_credentials` and `list_tools` to verify which external APIs or custom functions your AI logic chain is actually authorized to call. No more guesswork on permissions.
- Keep everything centralized. By connecting Flowise through Vinkius, you centralize control over multiple AI assets so your agent only needs one connection point.

## How It Works

The bottom line is you control complex AI pipelines using simple chat prompts, without ever leaving your agent interface.

1. Subscribe to this MCP and provide your specific Flowise Base URL and API Key. You find these keys in your Flowise Settings.
2. Your AI agent connects using the provided credentials, establishing a secure link to your internal Flowise environment.
3. You issue commands through natural conversation—for example, asking 'Show me the history for Legal-Assistant'—and your agent executes the required tool calls.

## Frequently Asked Questions

**How do I test a chatflow without using the Flowise UI? (predict)**
You use the `predict` tool. Just ask your agent to run a prediction on the specific chatflow ID you're targeting. It simulates the live user query and sends back the generated AI response in real-time.

**What is the difference between list_chatflows and list_agentflows? (list_chatflows, list_agentflows)**
Chatflows manage conversations; Agentflows define multi-step tasks. Use `list_chatflows` to see basic conversation bots, and use `list_agentflows` to see complex processes that require multiple steps or decisions.

**Can I find out what API keys are used by my AI agents? (list_credentials)**
Yes. Calling `list_credentials` will enumerate every secure credential component stored in your Flowise instance. It gives you a complete, auditable list of everything the agent can access.

**How do I see what external APIs my flow uses? (list_tools)**
Run `list_tools`. This tool pulls all custom functions and third-party integrations configured in your Flowise environment, letting you verify exactly which capabilities are available to the agent.

**How do I get the detailed architectural nodes and edges of a specific workflow using `get_chatflow`?**
The `get_chatflow` tool retrieves the full blueprint for any deployed chatflow. This lets you see every node and connection (edge), which is essential for understanding how data flows through complex logic chains.

**If my AI agent fails, what do I use to track down where the error occurred? Should I use `get_history`?**
You must use `get_history` to debug failures. It pulls precise execution traces and conversational logs, showing you exactly which steps failed and why they broke down.

**I need to verify what secrets are stored in the platform. How can I list all credentials using `list_credentials`?**
`list_credentials` enumerates every authentication component used by your AI logic chains. This gives you a central oversight of all stored API keys and connection details.

**How do I check the structure and definitions for complex, multi-step agent tasks using `list_agentflows`?**
`list_agentflows` provides a manifest of your compound Agentflows. This lets you see the defined complexity and multi-step reasoning logic that powers your most advanced AI applications.

**Can my agent run a prediction against a specific Flowise chatflow?**
Yes. Use the 'predict' tool. Provide the 'chatflow_id' and your question. The agent will command the Flowise backend to process the logic chain and return the AI-generated response directly in your chat.

**How do I see the past conversational logs for a chatflow via chat?**
Use the 'get_history' tool with the 'chatflow_id'. Your agent will retrieve the past execution traces and logs, helping you understand how users have interacted with that specific logic chain natively.

**Can I list all custom tools configured in my Flowise instance through the agent?**
Absolutely. Use the 'list_tools' tool. Your agent will retrieve custom tools and integrations configured in your environment, allowing you to audit available capabilities through natural conversation.