Open Source Relevance AI 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.

Paperclip treats a group of AI agents as an organization rather than a pile of terminals. It is a Node.js server with a React interface where you define a goal, hire agents into roles, and track the work and the spending from a single dashboard that looks like a task manager.

The framing is deliberate. If a coding agent is an employee, this is the company around it. You bring your own agents, from OpenClaw and Claude Code to Codex, Cursor, a bash script or an HTTP endpoint, and anything that can receive a heartbeat can be given a job.

The control plane is built on four pillars plus the money.

• Tasks: approval and review gates, proactive agent coworkers, and verification from diffs, screenshots and tests.
• Org chart: roles, reporting lines, delegation and scoped secrets across a mixed human and agent structure.
• Training: a skill studio, shared skills, evaluations, saved test runs and performance reviews for agents.
• Infrastructure: sandboxing, MCP servers, single sign-on, role-based access and cost controls.
• Budgets: monthly limits per agent, enforced atomically alongside task checkout so there is no double work and no runaway spend.

Agents keep their state between heartbeats instead of restarting cold, tasks carry their full goal ancestry so the reason for a job travels with it, and every conversation and tool call lands in an immutable audit log. One deployment can host several organizations with separate data, and orgs, agents and skills export as templates with secrets scrubbed.

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.

Agenta is an open-source workspace for building specialized agents that automate your work. You describe the job in chat, connect the applications the agent needs, and improve it through feedback rather than redrawing a workflow diagram every time the task shifts.

Agents are defined with open standards, an AGENTS.md file, skills, and MCP servers, so anything built for the wider ecosystem carries across. Claude Code, Pi, and Codex work as harnesses today, models can be self-hosted or reached through an API, and self-hosting lets you run agents against an existing Claude or ChatGPT subscription instead of metered billing.

Several pieces turn a single agent into something a whole team can use.

• Shared workspaces: you and your agent work on the same files, writing documents, organizing research, or maintaining a wiki.
• Human approval: permissions are set per tool, so some actions run automatically, some wait for you, and some are blocked outright.
• Background agents: runs start on a schedule or when an event fires in a connected app.
• Tracing and cost: every model and tool call is inspectable, with token usage and estimated cost tracked per agent.
• Integrations: connect through MCP directly, or reach more than 1,000 apps through Composio, including Gmail, Slack, Notion, and GitHub.

Every run is traced and every agent configuration is versioned, so a failure can be compared against the change that caused it. Team sharing and role-based access come with the open-source edition, an installable setup skill walks you through self-hosting, and a hosted cloud version exists for trying it first.

Rakazo runs persistent AI bots that keep their own conversations, memory, routines and history, rather than forgetting everything when a chat window closes. It is available on the web, as an Electron desktop app and through an Expo mobile app, and the complete stack can run locally. The project is in beta.

The codebase is TypeScript throughout, with React 19, Vite and Tailwind on the front end, Hono and oRPC on the API, PostgreSQL with Prisma for storage, Better Auth for accounts and Graphile Worker for background jobs. Model credentials stay yours, brought in through Pi.

Bots are given real machines and real tools to work with.

• Computers: shared team computers and isolated private ones, backed by Docker, E2B, Daytona, Box or a trusted local machine.
• Access: browser, terminal, file and graphical desktop control from inside a session.
• Delegation: bots hand work to peer bots or to short-lived subagents.
• Voice mode: spoken replies, dictation and calling a bot, using your own ElevenLabs, OpenAI, Cartesia or Fish Audio key.
• Integrations: Composio or Pipedream Connect catalogs, plus user-installed remote MCP servers, Treg endpoints and OpenAPI documents.

Installing the published images needs only Docker Engine, the Compose plugin, curl and OpenSSL; a script writes an environment file with random secrets and starts everything. Running the backend on a server keeps bots working while your laptop is shut. Connector credentials are encrypted on the server and never returned by the API.

Giselle assembles AI agents on a drag-and-drop canvas, so a workflow can be built and changed without hand-writing the orchestration. A single flow can call more than one model provider, which means no single vendor decides what the pipeline is able to do.

Running it locally takes a clone, a pnpm install and one provider key in an environment file, after which the development server serves the builder on port 3000. OpenAI, Anthropic and Google AI are supported, and at least one key is required. A hosted version offers the same features with free agent time each month, and a guide covers building with Giselle through AI coding assistants rather than a traditional editor.

The feature set is organized around delivery work rather than chat.

• GitHub operations: issues, pull requests and deployments handled by agents inside the existing workflow.
• Visual agent builder: agents created and modified through a drag-and-drop interface in minutes.
• Multi-model composition: GPT, Claude and Gemini in one flow, with agents choosing a model per task.
• Knowledge store: code and data searchable from one place, including GitHub vector store integration.
• Team collaboration: shared configurations and contextual awareness, still in development.
• Template hub: community-contributed agent templates for a one-click start, also in development.

Documented uses include a research assistant gathering from web and internal docs, a code reviewer wired into GitHub, a document generator producing specs and release notes, and a workflow automator chaining models across a business process. The project is under active development and licensed Apache 2.0.