
Archon
Beta release of Archon OS - the knowledge and task management backbone for AI coding assistants.
Stars: 12033

Archon is an AI meta-agent designed to autonomously build, refine, and optimize other AI agents. It serves as a practical tool for developers and an educational framework showcasing the evolution of agentic systems. Through iterative development, Archon demonstrates the power of planning, feedback loops, and domain-specific knowledge in creating robust AI agents.
README:
Power up your AI coding assistants with your own custom knowledge base and task management as an MCP server
Quick Start • Upgrading • What's Included • Architecture • Troubleshooting
Archon is currently in beta! Expect things to not work 100%, and please feel free to share any feedback and contribute with fixes/new features! Thank you to everyone for all the excitement we have for Archon already, as well as the bug reports, PRs, and discussions. It's a lot for our small team to get through but we're committed to addressing everything and making Archon into the best tool it possibly can be!
Archon is the command center for AI coding assistants. For you, it's a sleek interface to manage knowledge, context, and tasks for your projects. For the AI coding assistant(s), it's a Model Context Protocol (MCP) server to collaborate on and leverage the same knowledge, context, and tasks. Connect Claude Code, Kiro, Cursor, Windsurf, etc. to give your AI agents access to:
- Your documentation (crawled websites, uploaded PDFs/docs)
- Smart search capabilities with advanced RAG strategies
- Task management integrated with your knowledge base
- Real-time updates as you add new content and collaborate with your coding assistant on tasks
- Much more coming soon to build Archon into an integrated environment for all context engineering
This new vision for Archon replaces the old one (the agenteer). Archon used to be the AI agent that builds other agents, and now you can use Archon to do that and more.
It doesn't matter what you're building or if it's a new/existing codebase - Archon's knowledge and task management capabilities will improve the output of any AI driven coding.
- GitHub Discussions - Join the conversation and share ideas about Archon
- Contributing Guide - How to get involved and contribute to Archon
- Introduction Video - Getting started guide and vision for Archon
- Archon Kanban Board - Where maintainers are managing issues/features
- Dynamous AI Mastery - The birthplace of Archon - come join a vibrant community of other early AI adopters all helping each other transform their careers and businesses!
- Docker Desktop
- Node.js 18+ (for hybrid development mode)
- Supabase account (free tier or local Supabase both work)
- OpenAI API key (Gemini and Ollama are supported too!)
- (OPTIONAL) Make (see Installing Make below)
-
Clone Repository:
git clone -b stable https://github.com/coleam00/archon.git
cd archon
Note: The
stable
branch is recommended for using Archon. If you want to contribute or try the latest features, use themain
branch withgit clone https://github.com/coleam00/archon.git
-
Environment Configuration:
cp .env.example .env # Edit .env and add your Supabase credentials: # SUPABASE_URL=https://your-project.supabase.co # SUPABASE_SERVICE_KEY=your-service-key-here
IMPORTANT NOTES:
- For cloud Supabase: they recently introduced a new type of service role key but use the legacy one (the longer one).
- For local Supabase: set SUPABASE_URL to http://host.docker.internal:8000 (unless you have an IP address set up).
-
Database Setup: In your Supabase project SQL Editor, copy, paste, and execute the contents of
migration/complete_setup.sql
-
Start Services (choose one):
Full Docker Mode (Recommended for Normal Archon Usage)
docker compose up --build -d
This starts all core microservices in Docker:
- Server: Core API and business logic (Port: 8181)
- MCP Server: Protocol interface for AI clients (Port: 8051)
- UI: Web interface (Port: 3737)
Ports are configurable in your .env as well!
-
Configure API Keys:
- Open http://localhost:3737
- You'll automatically be brought through an onboarding flow to set your API key (OpenAI is default)
Once everything is running:
- Test Web Crawling: Go to http://localhost:3737 → Knowledge Base → "Crawl Website" → Enter a doc URL (such as https://ai.pydantic.dev/llms-full.txt)
- Test Document Upload: Knowledge Base → Upload a PDF
- Test Projects: Projects → Create a new project and add tasks
- Integrate with your AI coding assistant: MCP Dashboard → Copy connection config for your AI coding assistant
🛠️ Make installation (OPTIONAL - For Dev Workflows)
# Option 1: Using Chocolatey
choco install make
# Option 2: Using Scoop
scoop install make
# Option 3: Using WSL2
wsl --install
# Then in WSL: sudo apt-get install make
# Make comes pre-installed on macOS
# If needed: brew install make
# Debian/Ubuntu
sudo apt-get install make
# RHEL/CentOS/Fedora
sudo yum install make
🚀 Quick Command Reference for Make
Command | Description |
---|---|
make dev |
Start hybrid dev (backend in Docker, frontend local) ⭐ |
make dev-docker |
Everything in Docker |
make stop |
Stop all services |
make test |
Run all tests |
make lint |
Run linters |
make install |
Install dependencies |
make check |
Check environment setup |
make clean |
Remove containers and volumes (with confirmation) |
If you need to completely reset your database and start fresh:
⚠️ Reset Database - This will delete ALL data for Archon!
-
Run Reset Script: In your Supabase SQL Editor, run the contents of
migration/RESET_DB.sql
⚠️ WARNING: This will delete all Archon specific tables and data! Nothing else will be touched in your DB though. -
Rebuild Database: After reset, run
migration/complete_setup.sql
to create all the tables again. -
Restart Services:
docker compose --profile full up -d
-
Reconfigure:
- Select your LLM/embedding provider and set the API key again
- Re-upload any documents or re-crawl websites
The reset script safely removes all tables, functions, triggers, and policies with proper dependency handling.
Service | Container Name | Default URL | Purpose |
---|---|---|---|
Web Interface | archon-ui | http://localhost:3737 | Main dashboard and controls |
API Service | archon-server | http://localhost:8181 | Web crawling, document processing |
MCP Server | archon-mcp | http://localhost:8051 | Model Context Protocol interface |
Agents Service | archon-agents | http://localhost:8052 | AI/ML operations, reranking |
To upgrade Archon to the latest version:
-
Pull latest changes:
git pull
-
Check for migrations: Look in the
migration/
folder for any SQL files newer than your last update. Check the file created dates to determine if you need to run them. You can run these in the SQL editor just like you did when you first set up Archon. We are also working on a way to make handling these migrations automatic! -
Rebuild and restart:
docker compose up -d --build
This is the same command used for initial setup - it rebuilds containers with the latest code and restarts services.
- Smart Web Crawling: Automatically detects and crawls entire documentation sites, sitemaps, and individual pages
- Document Processing: Upload and process PDFs, Word docs, markdown files, and text documents with intelligent chunking
- Code Example Extraction: Automatically identifies and indexes code examples from documentation for enhanced search
- Vector Search: Advanced semantic search with contextual embeddings for precise knowledge retrieval
- Source Management: Organize knowledge by source, type, and tags for easy filtering
- Model Context Protocol (MCP): Connect any MCP-compatible client (Claude Code, Cursor, even non-AI coding assistants like Claude Desktop)
- MCP Tools: Comprehensive yet simple set of tools for RAG queries, task management, and project operations
- Multi-LLM Support: Works with OpenAI, Ollama, and Google Gemini models
- RAG Strategies: Hybrid search, contextual embeddings, and result reranking for optimal AI responses
- Real-time Streaming: Live responses from AI agents with progress tracking
- Hierarchical Projects: Organize work with projects, features, and tasks in a structured workflow
- AI-Assisted Creation: Generate project requirements and tasks using integrated AI agents
- Document Management: Version-controlled documents with collaborative editing capabilities
- Progress Tracking: Real-time updates and status management across all project activities
- WebSocket Updates: Live progress tracking for crawling, processing, and AI operations
- Multi-user Support: Collaborative knowledge building and project management
- Background Processing: Asynchronous operations that don't block the user interface
- Health Monitoring: Built-in service health checks and automatic reconnection
Archon uses true microservices architecture with clear separation of concerns:
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Frontend UI │ │ Server (API) │ │ MCP Server │ │ Agents Service │
│ │ │ │ │ │ │ │
│ React + Vite │◄──►│ FastAPI + │◄──►│ Lightweight │◄──►│ PydanticAI │
│ Port 3737 │ │ SocketIO │ │ HTTP Wrapper │ │ Port 8052 │
│ │ │ Port 8181 │ │ Port 8051 │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │ │
└────────────────────────┼────────────────────────┼────────────────────────┘
│ │
┌─────────────────┐ │
│ Database │ │
│ │ │
│ Supabase │◄──────────────┘
│ PostgreSQL │
│ PGVector │
└─────────────────┘
Service | Location | Purpose | Key Features |
---|---|---|---|
Frontend | archon-ui-main/ |
Web interface and dashboard | React, TypeScript, TailwindCSS, Socket.IO client |
Server | python/src/server/ |
Core business logic and APIs | FastAPI, service layer, Socket.IO broadcasts, all ML/AI operations |
MCP Server | python/src/mcp/ |
MCP protocol interface | Lightweight HTTP wrapper, MCP tools, session management |
Agents | python/src/agents/ |
PydanticAI agent hosting | Document and RAG agents, streaming responses |
- HTTP-based: All inter-service communication uses HTTP APIs
- Socket.IO: Real-time updates from Server to Frontend
- MCP Protocol: AI clients connect to MCP Server via SSE or stdio
- No Direct Imports: Services are truly independent with no shared code dependencies
- Lightweight Containers: Each service contains only required dependencies
- Independent Scaling: Services can be scaled independently based on load
- Development Flexibility: Teams can work on different services without conflicts
- Technology Diversity: Each service uses the best tools for its specific purpose
By default, Archon services run on the following ports:
- archon-ui: 3737
- archon-server: 8181
- archon-mcp: 8051
- archon-agents: 8052
- archon-docs: 3838 (optional)
To use custom ports, add these variables to your .env
file:
# Service Ports Configuration
ARCHON_UI_PORT=3737
ARCHON_SERVER_PORT=8181
ARCHON_MCP_PORT=8051
ARCHON_AGENTS_PORT=8052
ARCHON_DOCS_PORT=3838
Example: Running on different ports:
ARCHON_SERVER_PORT=8282
ARCHON_MCP_PORT=8151
By default, Archon uses localhost
as the hostname. You can configure a custom hostname or IP address by setting the HOST
variable in your .env
file:
# Hostname Configuration
HOST=localhost # Default
# Examples of custom hostnames:
HOST=192.168.1.100 # Use specific IP address
HOST=archon.local # Use custom domain
HOST=myserver.com # Use public domain
This is useful when:
- Running Archon on a different machine and accessing it remotely
- Using a custom domain name for your installation
- Deploying in a network environment where
localhost
isn't accessible
After changing hostname or ports:
- Restart Docker containers:
docker compose down && docker compose --profile full up -d
- Access the UI at:
http://${HOST}:${ARCHON_UI_PORT}
- Update your AI client configuration with the new hostname and MCP port
# Install dependencies
make install
# Start development (recommended)
make dev # Backend in Docker, frontend local with hot reload
# Alternative: Everything in Docker
make dev-docker # All services in Docker
# Stop everything (local FE needs to be stopped manually)
make stop
Best for active development with instant frontend updates:
- Backend services run in Docker (isolated, consistent)
- Frontend runs locally with hot module replacement
- Instant UI updates without Docker rebuilds
For all services in Docker environment:
- All services run in Docker containers
- Better for integration testing
- Slower frontend updates
# Run tests
make test # Run all tests
make test-fe # Run frontend tests
make test-be # Run backend tests
# Run linters
make lint # Lint all code
make lint-fe # Lint frontend code
make lint-be # Lint backend code
# Check environment
make check # Verify environment setup
# Clean up
make clean # Remove containers and volumes (asks for confirmation)
# View logs using Docker Compose directly
docker compose logs -f # All services
docker compose logs -f archon-server # API server
docker compose logs -f archon-mcp # MCP server
docker compose logs -f archon-ui # Frontend
Note: The backend services are configured with --reload
flag in their uvicorn commands and have source code mounted as volumes for automatic hot reloading when you make changes.
If you see "Port already in use" errors:
# Check what's using a port (e.g., 3737)
lsof -i :3737
# Stop all containers and local services
make stop
# Change the port in .env
If you encounter permission errors with Docker:
# Add your user to the docker group
sudo usermod -aG docker $USER
# Log out and back in, or run
newgrp docker
- Make not found: Install Make via Chocolatey, Scoop, or WSL2 (see Installing Make)
-
Line ending issues: Configure Git to use LF endings:
git config --global core.autocrlf false
- Check backend is running:
curl http://localhost:8181/health
- Verify port configuration in
.env
- For custom ports, ensure both
ARCHON_SERVER_PORT
andVITE_ARCHON_SERVER_PORT
are set
If docker compose
commands hang:
# Reset Docker Compose
docker compose down --remove-orphans
docker system prune -f
# Restart Docker Desktop (if applicable)
-
Frontend: Ensure you're running in hybrid mode (
make dev
) for best HMR experience -
Backend: Check that volumes are mounted correctly in
docker-compose.yml
- File permissions: On some systems, mounted volumes may have permission issues
Archon Community License (ACL) v1.2 - see LICENSE file for details.
TL;DR: Archon is free, open, and hackable. Run it, fork it, share it - just don't sell it as-a-service without permission.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for Archon
Similar Open Source Tools

Archon
Archon is an AI meta-agent designed to autonomously build, refine, and optimize other AI agents. It serves as a practical tool for developers and an educational framework showcasing the evolution of agentic systems. Through iterative development, Archon demonstrates the power of planning, feedback loops, and domain-specific knowledge in creating robust AI agents.

monoscope
Monoscope is an open-source monitoring and observability platform that uses artificial intelligence to understand and monitor systems automatically. It allows users to ingest and explore logs, traces, and metrics in S3 buckets, query in natural language via LLMs, and create AI agents to detect anomalies. Key capabilities include universal data ingestion, AI-powered understanding, natural language interface, cost-effective storage, and zero configuration. Monoscope is designed to reduce alert fatigue, catch issues before they impact users, and provide visibility across complex systems.

DreamLayer
DreamLayer AI is an open-source Stable Diffusion WebUI designed for AI researchers, labs, and developers. It automates prompts, seeds, and metrics for benchmarking models, datasets, and samplers, enabling reproducible evaluations across multiple seeds and configurations. The tool integrates custom metrics and evaluation pipelines, providing a streamlined workflow for AI research. With features like automated benchmarking, reproducibility, built-in metrics, multi-modal readiness, and researcher-friendly interface, DreamLayer AI aims to simplify and accelerate the model evaluation process.

zotero-mcp
Zotero MCP is an open-source project that integrates AI capabilities with Zotero using the Model Context Protocol. It consists of a Zotero plugin and an MCP server, enabling AI assistants to search, retrieve, and cite references from Zotero library. The project features a unified architecture with an integrated MCP server, eliminating the need for a separate server process. It provides features like intelligent search, detailed reference information, filtering by tags and identifiers, aiding in academic tasks such as literature reviews and citation management.

PAI
PAI is an open-source personal AI infrastructure designed to orchestrate personal and professional lives. It provides a scaffolding framework with real-world examples for life management, professional tasks, and personal goals. The core mission is to augment humans with AI capabilities to thrive in a world full of AI. PAI features UFC Context Architecture for persistent memory, specialized digital assistants for various tasks, an integrated tool ecosystem with MCP Servers, voice system, browser automation, and API integrations. The philosophy of PAI focuses on augmenting human capability rather than replacing it. The tool is MIT licensed and encourages contributions from the open-source community.

Dungeo_ai
OpenSource AI Tool for interactive text adventure with AI-generated storytelling and optional TTS narration support. Explore, role-play, and create story-driven adventures using AI. Requires Python 3.10+, pip, Ollama, NVIDIA CUDA Toolkit, git, and AllTalk TTS. Includes different modes for varied experiences and commands for gameplay. Licensed under MIT License with credit requirement for commercial use.

paelladoc
PAELLADOC is an intelligent documentation system that uses AI to analyze code repositories and generate comprehensive technical documentation. It offers a modular architecture with MECE principles, interactive documentation process, key features like Orchestrator and Commands, and a focus on context for successful AI programming. The tool aims to streamline documentation creation, code generation, and product management tasks for software development teams, providing a definitive standard for AI-assisted development documentation.

gemini-cli
Gemini CLI is an open-source AI agent that provides lightweight access to Gemini, offering powerful capabilities like code understanding, generation, automation, integration, and advanced features. It is designed for developers who prefer working in the command line and offers extensibility through MCP support. The tool integrates directly into GitHub workflows and offers various authentication options for individual developers, enterprise teams, and production workloads. With features like code querying, editing, app generation, debugging, and GitHub integration, Gemini CLI aims to streamline development workflows and enhance productivity.

robustmq
RobustMQ is a next-generation, high-performance, multi-protocol message queue built in Rust. It aims to create a unified messaging infrastructure tailored for modern cloud-native and AI systems. With features like high performance, distributed architecture, multi-protocol support, pluggable storage, cloud-native readiness, multi-tenancy, security features, observability, and user-friendliness, RobustMQ is designed to be production-ready and become a top-level Apache project in the message queue ecosystem by the second half of 2025.

evi-run
evi-run is a powerful, production-ready multi-agent AI system built on Python using the OpenAI Agents SDK. It offers instant deployment, ultimate flexibility, built-in analytics, Telegram integration, and scalable architecture. The system features memory management, knowledge integration, task scheduling, multi-agent orchestration, custom agent creation, deep research, web intelligence, document processing, image generation, DEX analytics, and Solana token swap. It supports flexible usage modes like private, free, and pay mode, with upcoming features including NSFW mode, task scheduler, and automatic limit orders. The technology stack includes Python 3.11, OpenAI Agents SDK, Telegram Bot API, PostgreSQL, Redis, and Docker & Docker Compose for deployment.

chat-ollama
ChatOllama is an open-source chatbot based on LLMs (Large Language Models). It supports a wide range of language models, including Ollama served models, OpenAI, Azure OpenAI, and Anthropic. ChatOllama supports multiple types of chat, including free chat with LLMs and chat with LLMs based on a knowledge base. Key features of ChatOllama include Ollama models management, knowledge bases management, chat, and commercial LLMs API keys management.

lyraios
LYRAIOS (LLM-based Your Reliable AI Operating System) is an advanced AI assistant platform built with FastAPI and Streamlit, designed to serve as an operating system for AI applications. It offers core features such as AI process management, memory system, and I/O system. The platform includes built-in tools like Calculator, Web Search, Financial Analysis, File Management, and Research Tools. It also provides specialized assistant teams for Python and research tasks. LYRAIOS is built on a technical architecture comprising FastAPI backend, Streamlit frontend, Vector Database, PostgreSQL storage, and Docker support. It offers features like knowledge management, process control, and security & access control. The roadmap includes enhancements in core platform, AI process management, memory system, tools & integrations, security & access control, open protocol architecture, multi-agent collaboration, and cross-platform support.

RepoMaster
RepoMaster is an AI agent that leverages GitHub repositories to solve complex real-world tasks. It transforms how coding tasks are solved by automatically finding the right GitHub tools and making them work together seamlessly. Users can describe their tasks, and RepoMaster's AI analysis leads to auto discovery and smart execution, resulting in perfect outcomes. The tool provides a web interface for beginners and a command-line interface for advanced users, along with specialized agents for deep search, general assistance, and repository tasks.

meeting-minutes
An open-source AI assistant for taking meeting notes that captures live meeting audio, transcribes it in real-time, and generates summaries while ensuring user privacy. Perfect for teams to focus on discussions while automatically capturing and organizing meeting content without external servers or complex infrastructure. Features include modern UI, real-time audio capture, speaker diarization, local processing for privacy, and more. The tool also offers a Rust-based implementation for better performance and native integration, with features like live transcription, speaker diarization, and a rich text editor for notes. Future plans include database connection for saving meeting minutes, improving summarization quality, and adding download options for meeting transcriptions and summaries. The backend supports multiple LLM providers through a unified interface, with configurations for Anthropic, Groq, and Ollama models. System architecture includes core components like audio capture service, transcription engine, LLM orchestrator, data services, and API layer. Prerequisites for setup include Node.js, Python, FFmpeg, and Rust. Development guidelines emphasize project structure, testing, documentation, type hints, and ESLint configuration. Contributions are welcome under the MIT License.

llm4s
LLM4S provides a simple, robust, and scalable framework for building Large Language Models (LLM) applications in Scala. It aims to leverage Scala's type safety, functional programming, JVM ecosystem, concurrency, and performance advantages to create reliable and maintainable AI-powered applications. The framework supports multi-provider integration, execution environments, error handling, Model Context Protocol (MCP) support, agent frameworks, multimodal generation, and Retrieval-Augmented Generation (RAG) workflows. It also offers observability features like detailed trace logging, monitoring, and analytics for debugging and performance insights.

AIPex
AIPex is a revolutionary Chrome extension that transforms your browser into an intelligent automation platform. Using natural language commands and AI-powered intelligence, AIPex can automate virtually any browser task - from complex multi-step workflows to simple repetitive actions. It offers features like natural language control, AI-powered intelligence, multi-step automation, universal compatibility, smart data extraction, precision actions, form automation, visual understanding, developer-friendly with extensive API, and lightning-fast execution of automation tasks.
For similar tasks

OpenAGI
OpenAGI is an AI agent creation package designed for researchers and developers to create intelligent agents using advanced machine learning techniques. The package provides tools and resources for building and training AI models, enabling users to develop sophisticated AI applications. With a focus on collaboration and community engagement, OpenAGI aims to facilitate the integration of AI technologies into various domains, fostering innovation and knowledge sharing among experts and enthusiasts.

GPTSwarm
GPTSwarm is a graph-based framework for LLM-based agents that enables the creation of LLM-based agents from graphs and facilitates the customized and automatic self-organization of agent swarms with self-improvement capabilities. The library includes components for domain-specific operations, graph-related functions, LLM backend selection, memory management, and optimization algorithms to enhance agent performance and swarm efficiency. Users can quickly run predefined swarms or utilize tools like the file analyzer. GPTSwarm supports local LM inference via LM Studio, allowing users to run with a local LLM model. The framework has been accepted by ICML2024 and offers advanced features for experimentation and customization.

AgentForge
AgentForge is a low-code framework tailored for the rapid development, testing, and iteration of AI-powered autonomous agents and Cognitive Architectures. It is compatible with a range of LLM models and offers flexibility to run different models for different agents based on specific needs. The framework is designed for seamless extensibility and database-flexibility, making it an ideal playground for various AI projects. AgentForge is a beta-testing ground and future-proof hub for crafting intelligent, model-agnostic autonomous agents.

atomic_agents
Atomic Agents is a modular and extensible framework designed for creating powerful applications. It follows the principles of Atomic Design, emphasizing small and single-purpose components. Leveraging Pydantic for data validation and serialization, the framework offers a set of tools and agents that can be combined to build AI applications. It depends on the Instructor package and supports various APIs like OpenAI, Cohere, Anthropic, and Gemini. Atomic Agents is suitable for developers looking to create AI agents with a focus on modularity and flexibility.

LongRoPE
LongRoPE is a method to extend the context window of large language models (LLMs) beyond 2 million tokens. It identifies and exploits non-uniformities in positional embeddings to enable 8x context extension without fine-tuning. The method utilizes a progressive extension strategy with 256k fine-tuning to reach a 2048k context. It adjusts embeddings for shorter contexts to maintain performance within the original window size. LongRoPE has been shown to be effective in maintaining performance across various tasks from 4k to 2048k context lengths.

ax
Ax is a Typescript library that allows users to build intelligent agents inspired by agentic workflows and the Stanford DSP paper. It seamlessly integrates with multiple Large Language Models (LLMs) and VectorDBs to create RAG pipelines or collaborative agents capable of solving complex problems. The library offers advanced features such as streaming validation, multi-modal DSP, and automatic prompt tuning using optimizers. Users can easily convert documents of any format to text, perform smart chunking, embedding, and querying, and ensure output validation while streaming. Ax is production-ready, written in Typescript, and has zero dependencies.

Awesome-AI-Agents
Awesome-AI-Agents is a curated list of projects, frameworks, benchmarks, platforms, and related resources focused on autonomous AI agents powered by Large Language Models (LLMs). The repository showcases a wide range of applications, multi-agent task solver projects, agent society simulations, and advanced components for building and customizing AI agents. It also includes frameworks for orchestrating role-playing, evaluating LLM-as-Agent performance, and connecting LLMs with real-world applications through platforms and APIs. Additionally, the repository features surveys, paper lists, and blogs related to LLM-based autonomous agents, making it a valuable resource for researchers, developers, and enthusiasts in the field of AI.

CodeFuse-muAgent
CodeFuse-muAgent is a Multi-Agent framework designed to streamline Standard Operating Procedure (SOP) orchestration for agents. It integrates toolkits, code libraries, knowledge bases, and sandbox environments for rapid construction of complex Multi-Agent interactive applications. The framework enables efficient execution and handling of multi-layered and multi-dimensional tasks.
For similar jobs

promptflow
**Prompt flow** is a suite of development tools designed to streamline the end-to-end development cycle of LLM-based AI applications, from ideation, prototyping, testing, evaluation to production deployment and monitoring. It makes prompt engineering much easier and enables you to build LLM apps with production quality.

deepeval
DeepEval is a simple-to-use, open-source LLM evaluation framework specialized for unit testing LLM outputs. It incorporates various metrics such as G-Eval, hallucination, answer relevancy, RAGAS, etc., and runs locally on your machine for evaluation. It provides a wide range of ready-to-use evaluation metrics, allows for creating custom metrics, integrates with any CI/CD environment, and enables benchmarking LLMs on popular benchmarks. DeepEval is designed for evaluating RAG and fine-tuning applications, helping users optimize hyperparameters, prevent prompt drifting, and transition from OpenAI to hosting their own Llama2 with confidence.

MegaDetector
MegaDetector is an AI model that identifies animals, people, and vehicles in camera trap images (which also makes it useful for eliminating blank images). This model is trained on several million images from a variety of ecosystems. MegaDetector is just one of many tools that aims to make conservation biologists more efficient with AI. If you want to learn about other ways to use AI to accelerate camera trap workflows, check out our of the field, affectionately titled "Everything I know about machine learning and camera traps".

leapfrogai
LeapfrogAI is a self-hosted AI platform designed to be deployed in air-gapped resource-constrained environments. It brings sophisticated AI solutions to these environments by hosting all the necessary components of an AI stack, including vector databases, model backends, API, and UI. LeapfrogAI's API closely matches that of OpenAI, allowing tools built for OpenAI/ChatGPT to function seamlessly with a LeapfrogAI backend. It provides several backends for various use cases, including llama-cpp-python, whisper, text-embeddings, and vllm. LeapfrogAI leverages Chainguard's apko to harden base python images, ensuring the latest supported Python versions are used by the other components of the stack. The LeapfrogAI SDK provides a standard set of protobuffs and python utilities for implementing backends and gRPC. LeapfrogAI offers UI options for common use-cases like chat, summarization, and transcription. It can be deployed and run locally via UDS and Kubernetes, built out using Zarf packages. LeapfrogAI is supported by a community of users and contributors, including Defense Unicorns, Beast Code, Chainguard, Exovera, Hypergiant, Pulze, SOSi, United States Navy, United States Air Force, and United States Space Force.

llava-docker
This Docker image for LLaVA (Large Language and Vision Assistant) provides a convenient way to run LLaVA locally or on RunPod. LLaVA is a powerful AI tool that combines natural language processing and computer vision capabilities. With this Docker image, you can easily access LLaVA's functionalities for various tasks, including image captioning, visual question answering, text summarization, and more. The image comes pre-installed with LLaVA v1.2.0, Torch 2.1.2, xformers 0.0.23.post1, and other necessary dependencies. You can customize the model used by setting the MODEL environment variable. The image also includes a Jupyter Lab environment for interactive development and exploration. Overall, this Docker image offers a comprehensive and user-friendly platform for leveraging LLaVA's capabilities.

carrot
The 'carrot' repository on GitHub provides a list of free and user-friendly ChatGPT mirror sites for easy access. The repository includes sponsored sites offering various GPT models and services. Users can find and share sites, report errors, and access stable and recommended sites for ChatGPT usage. The repository also includes a detailed list of ChatGPT sites, their features, and accessibility options, making it a valuable resource for ChatGPT users seeking free and unlimited GPT services.

TrustLLM
TrustLLM is a comprehensive study of trustworthiness in LLMs, including principles for different dimensions of trustworthiness, established benchmark, evaluation, and analysis of trustworthiness for mainstream LLMs, and discussion of open challenges and future directions. Specifically, we first propose a set of principles for trustworthy LLMs that span eight different dimensions. Based on these principles, we further establish a benchmark across six dimensions including truthfulness, safety, fairness, robustness, privacy, and machine ethics. We then present a study evaluating 16 mainstream LLMs in TrustLLM, consisting of over 30 datasets. The document explains how to use the trustllm python package to help you assess the performance of your LLM in trustworthiness more quickly. For more details about TrustLLM, please refer to project website.

AI-YinMei
AI-YinMei is an AI virtual anchor Vtuber development tool (N card version). It supports fastgpt knowledge base chat dialogue, a complete set of solutions for LLM large language models: [fastgpt] + [one-api] + [Xinference], supports docking bilibili live broadcast barrage reply and entering live broadcast welcome speech, supports Microsoft edge-tts speech synthesis, supports Bert-VITS2 speech synthesis, supports GPT-SoVITS speech synthesis, supports expression control Vtuber Studio, supports painting stable-diffusion-webui output OBS live broadcast room, supports painting picture pornography public-NSFW-y-distinguish, supports search and image search service duckduckgo (requires magic Internet access), supports image search service Baidu image search (no magic Internet access), supports AI reply chat box [html plug-in], supports AI singing Auto-Convert-Music, supports playlist [html plug-in], supports dancing function, supports expression video playback, supports head touching action, supports gift smashing action, supports singing automatic start dancing function, chat and singing automatic cycle swing action, supports multi scene switching, background music switching, day and night automatic switching scene, supports open singing and painting, let AI automatically judge the content.