Open Source Microsoft Copilot Studio Alternatives

Dify is a development platform for applications built on language models. Its interface gathers AI workflows, retrieval pipelines, agent definitions, model management and observability in one place, which removes the usual scattering of prompt files, vector stores and glue scripts across a codebase.

Work starts on a visual canvas where a workflow is built and tested, with a prompt IDE beside it for drafting instructions and comparing how models respond. Everything built this way is also exposed through an API, so the platform sits behind your own product rather than replacing it.

The platform is organized around a handful of pieces.

• Model coverage: hundreds of proprietary and open models from dozens of inference providers, including any OpenAI-compatible endpoint.
• RAG pipeline: document ingestion through retrieval, with text extraction from PDFs, presentations and other common formats.
• Agents: defined through function calling or ReAct, with more than fifty built-in tools alongside your own.
• LLMOps: logs and performance are tracked over time so prompts, datasets and models improve on production data.
• Observability integrations: Opik, Langfuse and Arize Phoenix connect for tracing.

The quickest path is Docker Compose from the repository, on a machine with at least two CPU cores and four gigabytes of memory, after which the dashboard initializes in a browser. Deploying from source is documented for anyone extending it. A hosted cloud and an enterprise edition exist, but the community edition is the one you run yourself.

Langflow gives agents and AI workflows a visual authoring surface and then publishes what you build. Each flow becomes an API endpoint or an MCP server, so the thing you sketched in a browser is immediately callable from an application on any framework or stack.

Components are Python underneath and the source is open at every node, which means a built-in block can be adapted instead of worked around. An interactive playground runs a flow with step-by-step control while you refine it.

The pieces that matter once a flow leaves the canvas.

• Deploy as an API: flows are called from applications, or exported as JSON for Python apps.
• MCP server: a flow becomes a tool that any MCP client can call.
• Multi-agent orchestration: conversation management and retrieval across several agents in one flow.
• Observability: LangSmith, LangFuse and other integrations connect for tracing.
• Batteries included: major model providers, vector databases and a growing library of AI tools ship with it.

Installing locally needs Python 3.10 to 3.14 and the uv package manager, and the server comes up on port 7860, with a Docker image and a source build documented as well. Langflow Desktop bundles every dependency for Windows and macOS, which is the shortest path for anyone who would rather not manage Python environments. Deployment guides cover the major clouds.

Flowise puts agent building on a canvas, where nodes are connected into agentflows and the result runs as an application you host yourself. Getting started is a global npm package and a start command on Node 20 or later, with Docker Compose or a locally built image as the alternatives.

The repository is a monorepo whose parts make the extension points clear.

• Server: the Node backend that serves the API logic.
• UI: the React frontend where flows are assembled.
• Components: the third-party node integrations.
• API documentation: Swagger interface docs generated from the Express routes.

Configuration goes through environment variables in a file inside the server package, and a development build reloads the running app whenever code changes. Self-hosting guides cover AWS, Azure, Google Cloud, DigitalOcean and Alibaba Cloud, along with Railway, Northflank and Render, while Flowise Cloud exists for teams that would rather not operate it.

One caveat matters before adopting it: the repository has been archived, and the README points readers to a discussion about the future of Flowise.

Licensing is split. Most of the code is Apache 2.0, third-party components keep their own terms, and an enterprise directory inside the server package is covered by a commercial license instead.

Agno is a framework and a runtime for agent platforms. Agents are written with the Agno SDK, served by the AgentOS runtime and administered through the AgentOS UI, so the whole stack stays on infrastructure you control rather than behind someone else's dashboard.

Starter templates get a platform running under Docker with a REST API, a Postgres database for data and traces, an MCP server and a control plane. Equivalent templates exist for Railway, AWS, GCP, Azure, Fly, Render, Modal and Helm, differing only in their deploy scripts.

The runtime carries the parts most teams end up building for themselves.

• Production API: more than 50 endpoints with server sent events and websockets to build a product on.
• Storage: keeps sessions, memory, knowledge and traces in your own database.
• Human approval: pauses runs for confirmation and blocks tools that require an administrator.
• Security: provides JWT based RBAC with multi user and multi tenant isolation.
• Interfaces: exposes agents through Slack, Telegram, WhatsApp, Discord, AG-UI and A2A.

More than 100 prebuilt toolkits connect to services such as GitHub, Slack and Postgres, context providers pull live data from wikis, Drive and MCP sources, and observability runs on OpenTelemetry tracing with run history and audit logs. Cron scheduling and background jobs need no extra infrastructure. One telemetry event is sent per agent run, never prompts or outputs, and an environment variable turns it off.

CopilotKit started as a React library and now sits as a horizontal layer between your agents and your users, so one agent backend can serve a web app, a mobile app and a team workspace. It removes the work of rebuilding a chat surface and a state bridge for every frontend you ship.

The SDK is built on AG-UI, the wire protocol the same team maintains, which carries the transport while CopilotKit supplies the interface layer for each framework. React and Next.js are generally available, with Angular, Vue, React Native, Slack and Microsoft Teams supported. The npx copilotkit create command scaffolds a working setup in minutes and needs only an LLM key.

The library groups its work into a few building blocks.

• Chat UI: a customizable interface that handles message streaming, tool calls and agent responses.
• Generative UI: agents create and update components at runtime according to user intent and agent state.
• Shared state: a synchronized layer that agents and interface components both read from and write to in real time.
• Human-in-the-loop: execution pauses so a person can confirm, edit or supply input before the agent continues.
• Channels SDK: an agent you already built drops into Slack or Microsoft Teams with the same tools and approvals.

A self-learning capability in early access lets agents improve from user interactions without fine-tuning, adapting per user and keeping threads across sessions, available in the cloud or self-hosted. Installable agent skills also teach coding assistants how to set up, integrate, debug and upgrade CopilotKit inside a project directory.

FastGPT is a platform for building AI agents, bundling document processing, retrieval and model calls so a team can assemble an assistant over its own material instead of joining those pieces together by hand.

Applications are composed in a visual Flow editor, where conversation workflows and plugin workflows are wired from nodes, including basic RPA steps, user interaction points and two way MCP. Knowledge bases sit underneath, feeding answers with citations the operator can inspect.

The feature set is organized around building, debugging and running an assistant.

• Knowledge bases: multiple libraries reused and mixed, hybrid retrieval with reranking, and an API backed knowledge base.
• Ingestion: TXT, MD, HTML, PDF, Docx, PPTX, CSV and XLSX files, plus URL reading, manual entry, direct segmentation and QA split import.
• Debugging: single point search tests, full call chain logs, editable and deletable citations, and application evaluation.
• Operations: login free share windows, one click iframe embedding, unified conversation records with annotation, and application logs.

Self hosting runs through Docker Compose with a configuration script, reaching the interface on port 3000 with a default root account, and a Sealos one click deployment is documented as an alternative. A hosted cloud edition and a commercial edition exist for teams wanting deeper support. The repository uses the FastGPT Open Source License, which permits direct commercial use as a backend service but not offering it as SaaS.

MaxKB, short for Max Knowledge Brain, is an open-source platform for building enterprise-grade agents. It gathers retrieval, workflow orchestration and tool use into one product, so those pieces do not have to be assembled and maintained separately.

It is applied in intelligent customer service, corporate internal knowledge bases, academic research and education. Grounding answers in material you supply is what reduces hallucination from the underlying model and makes the question and answer experience usable.

Five capabilities describe what the platform covers.

• RAG pipeline: documents are uploaded directly or crawled from online sources, then split and vectorized automatically.
• Agentic workflow: a workflow engine, a function library and MCP tool use orchestrate processes for complex business scenarios.
• Integration: zero-coding integration adds question answering to third-party business systems that already exist.
• Model-agnostic: private models such as DeepSeek, Llama and Qwen sit alongside public ones like OpenAI, Claude, Gemini and MiniMax.
• Multi modal: text, image, audio and video are natively supported as both input and output.

A single Docker command starts the container and serves the web interface on port 8080 with a default administrator account. Underneath it runs Vue.js on the front end, Python with Django on the back, LangChain for the model layer and PostgreSQL with pgvector for storage. An offline installation guide covers environments that cannot pull the image, and the whole thing is licensed under GPLv3.

This repository is the open part of Botpress, a platform for building chatbots and assistants. Rather than the product itself, it holds the integrations published on the Botpress Hub, the developer tooling behind them, example bots written entirely as code, and the plugins the Studio will use.

Development starts with the Botpress CLI. Install it globally, run bp init to generate an integration from one of the templates, then edit the definition and implementation files it produces. A deploy pushes the current version into your workspace where every bot can use it, and a public deploy publishes it to the Hub, after which that version is frozen.

The repository is organized around four kinds of content.

• Integrations: the public integrations maintained by Botpress, open to community contributions and new submissions.
• Devtools: the CLI for building and deploying, a type-safe client for the APIs, and the SDK integrations are written against.
• Bots: examples built only from the client, SDK and CLI, offered as a programmatic route rather than the recommended one.
• Plugins: Studio plugins, listed in the repository as coming soon.

Local development needs git, Node.js and pnpm, plus the Microsoft Visual C++ redistributable on Windows, after which install, build and check all run as pnpm scripts. Everything here is MIT licensed. Questions about on-premise Botpress v12 belong in its own repository rather than this one.