awesome-repositories.com
المدونة
MCP
awesome-repositories.com

اكتشف أفضل مستودعات المصادر المفتوحة باستخدام بحث مدعوم بالذكاء الاصطناعي.

استكشفعمليات بحث منسقةبدائل مفتوحة المصدربرمجيات ذاتية الاستضافةالمدونةخريطة الموقع
المشروعحولكيفية ترتيب النتائجالصحافةخادم MCP
قانونيالخصوصيةالشروط
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
camel-ai avatar

camel-ai/camel

0
View on GitHub↗
docs.camel-ai.org
↗

Camel

This project is a comprehensive framework for building and managing autonomous agent systems. It provides a unified architecture for orchestrating multi-agent societies, where specialized agents collaborate through roleplay to decompose and solve complex tasks. The system integrates language models with external environments, enabling agents to perform real-world actions through a standardized tool-calling abstraction layer.

The framework distinguishes itself through its focus on iterative reasoning and data reliability. It employs automated feedback loops to refine agent outputs and self-evaluate reasoning traces, ensuring high-quality results. To maintain operational integrity, the system enforces schema-based output parsing for reliable workflow integration and utilizes sandboxed environments for secure, isolated code execution.

Beyond its core orchestration capabilities, the project includes a suite of utilities for retrieval-augmented generation and synthetic data production. It supports persistent memory management via vector-based context retrieval and provides extensive tooling for web automation, API integration, and human-in-the-loop oversight. The platform is designed to be model-agnostic, offering a consistent interface for interacting with a wide range of proprietary and open-source language models.

Features

  • Agentic LLM Frameworks - Provides a modular framework for building autonomous agents with support for tool use, web browsing, and sandboxed code execution.
  • Multi-Agent Orchestration Frameworks - Coordinates autonomous agents through turn-taking dialogues where specialized roles collaborate to solve complex tasks.
  • Agent Tool Integrations - Provides a standardized tool-calling abstraction layer for agents to interact with external APIs, databases, and local files.
  • Multi-Agent Systems - Coordinates teams of specialized autonomous agents that collaborate to solve complex tasks through structured roleplay.

بحث بالذكاء الاصطناعي

استكشف المزيد من المستودعات الرائعة

صف ما تحتاجه بلغة بسيطة — وسيقوم الذكاء الاصطناعي بترتيب آلاف المشاريع مفتوحة المصدر المنسقة حسب الصلة.

Start searching with AI
17,253 نجوم·1,966 تفرعات·Python·Apache-2.0·24 مشاهدات
  • Model Abstraction Layers - Provides a consistent abstraction for interacting with various proprietary and open-source language models.
  • Multi-Agent Orchestration - Coordinates communication between multiple specialized agents to collaboratively solve complex tasks through structured role-playing scenarios.
  • Multi-Agent Orchestrators - Orchestrates collaborative multi-agent societies that solve complex tasks through roleplay and structured interaction.
  • Agent State Persistence - Stores and retrieves agent sessions, chat history, and internal context across execution turns.
  • Multi-Agent Orchestration Platforms - Manages multi-turn interactions with language models, supporting memory, tool usage, and dynamic model selection.
  • Iterative Refinement Workflows - Refines agent outputs through automated self-evaluation and multi-step verification loops.
  • Agentic Workflow Automation - Decomposes high-level objectives into actionable subtasks and executes them through autonomous agents with human-in-the-loop oversight.
  • External Tool Integration - Equips agents with the ability to interact with external tools and APIs to perform real-world actions.
  • Tool Calling - Enables language models to identify, select, and execute external functions during the generation process.
  • Human-in-the-Loop Systems - Integrates human-in-the-loop oversight to monitor and guide agent decision-making processes.
  • Retrieval-Augmented Generation Frameworks - Provides a platform for connecting language models to external knowledge bases and graph structures to improve response accuracy.
  • Retrieval Augmented Generation Pipelines - Integrates external data retrieval with language model generation to provide context-aware and factually grounded responses.
  • Self-Improving Logic - Implements iterative feedback loops to self-evaluate and refine reasoning traces for high-quality task execution.
  • Schema-Enforced Output Parsers - Constrains language model responses to predefined data structures for reliable workflow integration.
  • Retrieval Augmentation - Grounds language model responses using external data retrieved from vector stores.
  • Code Execution Sandboxes - Runs dynamic code snippets in isolated environments to ensure secure and reproducible task processing.
  • Abstraction Layers - Standardizes external function definitions and execution logic for uniform agent-tool interaction.
  • Long-term Memory Stores - Maintains persistent storage of chat history and learned knowledge across sessions for long-horizon context.
  • Agent-to-Agent Communication - Provides standardized message structures to ensure consistent communication across diverse agent workflows.
  • Agent Evaluation Tools - Evaluates the accuracy of agent function calling through standardized benchmarks.
  • Agent Memory Storage - Enables saving and loading of agent memory to local storage.
  • Agent Memory Systems - Stores and retrieves past interaction data to help agents maintain context and coherence across multi-turn conversations.
  • Agent Monitoring - Tracks agent lifecycles, tool usage, and decision-making processes to provide visibility into autonomous operations.
  • Agentic Reasoning Loops - Implements self-taught reasoning loops where agents evaluate and improve their own reasoning traces through feedback.
  • Critic Agent Loops - Integrates critic agents into conversation flows to automatically review, evaluate, and improve the quality of generated responses.
  • Agent System Prompts - Defines agent system prompts to establish behavioral constraints and output formatting.
  • Agent Tooling - Integrates external functions into agents to enable them to perform complex tasks beyond native language capabilities.
  • Agent Configurations - Initializes conversational agents with custom prompts, memory, and model backends.
  • AI Agent Builders - Instantiates autonomous agents with custom system instructions, domain specializations, and tool access for collaborative team roles.
  • Role-Based Agent Orchestration - Structures multi-agent collaboration by dynamically assigning specific roles and responsibilities based on task descriptions.
  • Agent Persona Definitions - Utilizes pre-defined prompt templates to initialize specialized agents with specific roles, task types, and behavioral instructions.
  • Agent Prompt Templates - Uses prompt templates to structure agent instructions and role definitions for consistent output.
  • Tool Use & Execution - Manages execution logic for external functions, including automatic selection and parallel processing of tool requests.
  • Agent Tool Execution - Invokes external functions and services through a standardized tool-calling abstraction layer.
  • MCP Server Integrations - Integrates external tools via standardized communication protocols to expand agent functional capabilities.
  • Automated Chain-of-Thought - Constructs step-by-step reasoning paths using dual-agent verification to ensure high-quality problem-solving traces.
  • Code Execution Agents - Enables agents to run code snippets to perform computations and solve technical problems.
  • Code Execution Environments - Provides sandboxed environments for agents to execute generated Python code securely.
  • External Knowledge Integrators - Connects agents to external databases and APIs to enable retrieval-augmented generation.
  • Structured Tool Invocations - Parses model responses to identify and retrieve structured tool call requests for agent execution.
  • Graph Retrieval Augmented Generation - Combines knowledge retrieval with graph-based reasoning to improve the accuracy of generated responses.
  • Human Approval - Facilitates human intervention by pausing agent execution for manual input and oversight.
  • Human-in-the-Loop Tools - Equips agents with interactive toolkits to query users directly through the console for input or feedback during task execution.
  • Human-in-the-Loop Workflows - Equips agents with tools to pause execution and request human input or approval to resolve blockers during workflows.
  • Instruction Datasets - Synthesizes new questions from existing examples to scale instruction-following dataset development.
  • Language Model Fine-Tuning - Trains models using supervised or preference-based learning techniques to optimize performance on specific tasks.
  • Large Language Models - Provides a unified interface for initializing and managing various large language models to handle text generation and reasoning tasks.
  • LLM Provider Integrations - Provides a unified interface for connecting to and managing multiple proprietary and open-source language model providers.
  • Multi-Agent Research Frameworks - Orchestrates collaborative research by distributing tasks across specialized agents and synthesizing results.
  • Multi-Agent Task Orchestrators - Coordinates interactions between specialized agents that use tools to perform complex workflows like research and report generation.
  • RAG Evaluation Frameworks - Provides standardized performance evaluation for retrieval-augmented generation pipelines.
  • Reasoning Parsers - Extracts and structures internal chain-of-thought reasoning steps from model outputs for high-quality synthetic datasets.
  • Reasoning Orchestrators - Orchestrates multi-agent reasoning loops and verification algorithms to produce high-quality, structured reasoning paths for training.
  • Recursive Task Decomposers - Breaks complex assignments into smaller subtasks for execution and aggregates results to complete primary objectives.
  • Retrieval-Augmented Agents - Equips autonomous agents with retrieval tools to query external data sources and incorporate findings into their decision-making.
  • Structured Output Enforcements - Forces models to generate responses in specific formats like JSON to ensure compatibility with downstream data processing tasks.
  • Synthetic Data Curation Tools - Filters, deduplicates, and samples generated data to ensure high quality for downstream model training.
  • Synthetic Data Generation - Leverages agentic workflows to generate high-quality synthetic datasets for model training and fine-tuning.
  • Synthetic Data Generators - Automates the creation and curation of high-quality training datasets through multi-agent interaction and reasoning loops.
  • Synthetic Data Pipelines - Orchestrates multi-agent interactions and automated reasoning loops to create and refine high-quality training datasets.
  • Vector Retrieval Abstractions - Provides a unified abstraction layer for semantic memory retrieval and vector database interaction across long-running agent sessions.
  • Security Guardrails - Evaluates function calls against risk thresholds to block unauthorized or dangerous operations.
  • Browser Automation - Enables autonomous agents to navigate websites, fill forms, and extract data through programmatic browser control.
  • Agent Configurations - Adjusts operational parameters like token limits and termination criteria to control agent behavior.
  • Agent Interfaces - Implements a standardized interface for creating specialized agents by defining core logic for task execution and decision-making.
  • Agentic Context Management - Maintains interaction history within finite windows to enable in-context learning and manual memory management.
  • Dynamic Command Execution - Enables agents to execute shell commands for system interaction and task processing.
  • Autonomous Web Agents - Enables autonomous agents to perform multi-step web tasks and data gathering by interpreting natural language goals.
  • Human-in-the-loop Workflows - Intercepts agent tool execution requests to prompt a human for verification before the action proceeds, ensuring oversight for sensitive operations.
  • Agent Context Management - Defines custom logic for selecting and formatting relevant information from memory to optimize agent responses and manage token usage.
  • Conversational AI Agents - Instantiates autonomous agents with custom system instructions and model configurations to process and respond to user messages.
  • Agent Evaluation Frameworks - Analyzes agent outputs to select the most appropriate action, utilizing retry logic and context management to ensure valid decision-making.
  • Agentic Web Interaction - Captures and stores interaction logs from autonomous agents to facilitate training data generation.
  • Autonomous Task Execution - Deploys autonomous frameworks that plan and execute action sequences with minimal human intervention.
  • Code Execution Tools - Equips agents with tools to execute code and interact with external environments for automation.
  • External Tool Execution - Connects agents to external servers to perform specialized tasks using standardized protocols.
  • Grounded Answer Generation - Transforms raw source text into complex multi-hop question-answer datasets using orchestrated pipelines.
  • Knowledge Retrieval Systems - Accesses stored information using semantic search and file lookups during agent interactions.
  • Repository Context Injection - Integrates repository content into agent prompts to provide codebase context for code generation tasks.
  • Large Language Model Configurations - Configures generation parameters like temperature and sampling limits for language models.
  • Model Provider Configurations - Facilitates integration with multiple model providers through unified authentication and routing configurations.
  • Multi-Agent Systems - Allows for the creation of custom agent logic to perform specific, repeatable tasks within a multi-agent system.
  • Prompt Iteration Workflows - Refines and expands simple prompts into complex instructions through iterative evolution strategies.
  • Structured Data Extraction - Uses language models to parse web content into predefined schemas for reliable data extraction.
  • Synthetic Reasoning Data Generators - Orchestrates reasoning models to distill complex thought processes into high-quality synthetic reasoning datasets.
  • Tool Schema Definitions - Converts functions and tool definitions into standardized schemas required for agent execution.
  • Training Data Generation - Preprocesses raw text and extracts information to format structured training pairs for machine learning models.
  • Vector Database Configurations - Integrates external vector databases and embedding models to enable semantic search and retrieval within agent memory systems.
  • Vector Similarity Search - Implements vector similarity search for semantic retrieval within agent memory.
  • Agent Frameworks - Multi-agent framework for role-play and collaboration.
  • Agent Orchestration - Multi-agent framework for diverse toolkits and use cases.
  • Autonomous Agent Frameworks - Library for studying communicative and collaborative agent interactions.
  • Data Ingestion - Loads, parses, and prepares unstructured data from diverse external sources for downstream agent processing.
  • Vector-Database-Backed Retrievals - Locates relevant information within documents by calculating semantic similarity for agent context.
  • Hybrid Search - Combines vector-based similarity search with graph-based relationship traversal for complex information retrieval.
  • Semantic Search Engines - Uses vector embeddings to retrieve information based on conceptual meaning for improved context quality.
  • Semantic Information Retrieval - Finds data based on meaning and context to provide relevant information for agent tasks.
  • Vector Database Integrations - Connects applications to specialized databases designed for high-dimensional vector storage and retrieval.
  • AI Agent Benchmarks - Benchmarks the ability of language models to interact with external tools and APIs.
  • Isolated Execution Environments - Creates and manages isolated sandboxed workspaces for secure, dependency-controlled execution.
  • Sandboxed Execution Environments - Configures isolated execution instances with custom namespaces and security constraints to safely handle automated tasks.
  • Agentic Task Orchestration - Monitors agent execution and automatically triggers recovery protocols like retries or replanning upon failure.
  • Function Definitions - Creates callable functions with defined parameters to allow agents to interact with external systems.
  • Sandboxed Code Execution Environments - Executes agent tools and scripts in secure, isolated environments to ensure safety.
  • Command Restrictions - Enforces security policies by blocking dangerous commands or limiting execution to allowlisted operations.
  • Web Scraping and Automation - Triggers remote web scraping and automation workflows with custom parameters and resource constraints.
  • Agent Communication Protocols - Transforms conversational agents into standardized backends for external application interaction.
  • Agent Lifecycle Management - Controls the operational state of agents through standardized methods for resetting memory and executing task steps.
  • Agent Simulation Environments - Executes sequential decision-making tasks within a structured environment to evaluate agent performance or generate synthetic training data.
  • Agent Task Execution - Implements chat-based agents that utilize internal locks and state tracking for reliable, sequential operations.
  • Agentic Model Integrations - Integrates external machine learning models as tools within agent systems to perform specialized tasks.
  • Agent Action Representations - Records agent outputs and metadata to enable verification and tracking of decision-making processes.
  • Agent Server APIs - Wraps agent instances as network-accessible services for integration with external systems.
  • AI Code Interpreters - Allows dynamic configuration of the action space and code types available to the agent interpreter.
  • Chat Completion Services - Supports configuration of chat completion parameters including tool-calling behavior.
  • Context Compression - Compresses long chat logs into concise summaries to maintain manageable context windows.
  • Data Processing Pipelines - Defines configurable pipelines for transforming and preparing data specifically for multi-agent system training and evaluation.
  • Embedding Generators - Transforms text into vector representations to enable semantic search and memory within agent workflows.
  • External Execution Providers - Supports the execution of external code strings in isolated subprocesses for agent tasks.
  • Conversation History Condensation - Generates structured prompts to condense conversation history into concise summaries for context management.
  • Local Model Runtimes - Enables local execution of open-source models to maintain privacy and reduce cloud dependency.
  • Data Preparation Tools - Cleans, formats, and transforms raw data into structures suitable for agent retrieval and analysis.
  • Image Encoder Embedding Extractions - Converts visual inputs into numerical vector representations for downstream similarity and classification tasks.
  • Inference Configuration Parameters - Provides granular control over inference settings to manage model behavior and output quality.
  • Failover Strategies - Automatically switches between model providers to ensure continuous operation during service instability.
  • Model Configuration - Standardizes model configurations to ensure consistent behavior across different model implementations.
  • Model Parameter Configurations - Offers a consistent interface for adjusting model parameters across various supported providers.
  • Multi-Agent Reasoning Environments - Provides automated critique and evaluation of agent reasoning traces to improve solution quality.
  • Prompt Variation Generators - Applies evolution strategies to prompts to increase complexity and generate diverse training data.
  • Generated Data Validators - Applies configurable filters to evaluate and discard low-quality instructions during the generation process.
  • Synthetic Instruction Generators - Creates machine-generated task instructions by combining seed samples with automated generation and validation.
  • Tool Call Data Generators - Automates the creation of human-like user queries and tool call outputs for training and testing agent systems.
  • Vector Embeddings - Generates vector representations for text and images to facilitate semantic search and memory.
  • Web Content Scrapers - Retrieves and converts online information into structured markdown format for automated data generation.
  • Parallel Task Batching - Improves throughput by executing large-scale reasoning tasks in parallel using dynamic batch sizing.
  • Dataset Management Tools - Organizes, downloads, and prepares datasets for training or evaluating agent behaviors.
  • File Export Utilities - Saves generated data points into JSONL format for large-scale storage and downstream processing.
  • Text Vectorizers - Transforms text and images into dense numerical vector representations for semantic search and similarity analysis.
  • Shell Command Runners - Provides interfaces for agents to execute shell commands within sandboxed environments.
  • Web Scraping - Extracts structured content from web pages for integration into artificial intelligence workflows.
  • Agent Deployment Platforms - Facilitates the deployment of autonomous agents to external messaging services.
  • Solution Rationale Generators - Generates code-based rationales and step-by-step reasoning to provide verifiable solutions for synthetic data.
  • Chat Bot Integrations - Integrates autonomous agents into messaging platforms to handle user interactions and provide automated responses.
  • Chat Bots - Connects autonomous agents to messaging platforms to automate responses through dedicated bot interfaces.
  • Discord Integrations - Connects autonomous agents to messaging platforms to monitor channels and respond to user interactions.
  • Slack Integrations - Initializes and manages messaging application servers to handle events and authentication flows.
  • Output Validators - Grades generated answers by using specialized agents to compare outputs against expected results.
  • Presentation Deck Rendering - Provides declarative wrappers to manage and render the structural composition of presentation slides from structured data.
  • Message-Passing Agent Orchestrators - Constructs and transforms structured messages for communication between agents in a multi-agent system.
  • Agent Observability Tools - Structures input context and observations to maintain consistent state for agent decision-making.
  • Agent Capability Registries - Provides registries for searching and identifying available server tools to expand agent capabilities.
  • Agent Result Aggregators - Aggregates observations and reward scores from agent actions within simulated environments.
  • Nebius AI - Allows fine-tuning of Nebius AI model generation settings like temperature and tool usage.
  • ModelScope - Enables configuration of text generation parameters for ModelScope service APIs.
  • Chat Message Formats - Converts internal message objects into standard formats to ensure compatibility with various language model backends.
  • Context Optimization Utilities - Reduces token usage by limiting processed data to visible viewport elements for vision models.
  • RAG Dataset Annotators - Enriches datasets with generated context and answer fields by applying custom transformation functions.
  • External Service Integrations - Enables agents to interact with third-party platforms and external services beyond the local environment.
  • Knowledge Graph Extraction - Provides automated pipelines for identifying entities and relationships to build structured knowledge representations from unstructured text.
  • Multi-Agent Output Evaluation - Captures and structures the information returned by an agent to facilitate further reasoning or integration into a multi-agent workflow.
  • Anthropic - Allows fine-tuning of Anthropic model generation settings like token limits and sampling strategies.
  • Cohere - Allows fine-tuning of Cohere model generation settings like temperature and token limits.
  • Gemini - Allows fine-tuning of Gemini model generation settings like temperature and response formats.
  • Mistral - Allows fine-tuning of Mistral model generation settings like temperature and sampling seeds.
  • Nvidia - Allows fine-tuning of Nvidia model generation settings like temperature and sampling diversity.
  • WatsonX - Allows fine-tuning of WatsonX model generation settings like temperature and penalties.
  • Multimodal Agent Capabilities - Enables agents to process and generate visual content as part of their task-solving workflows.
  • Optical Character Recognition - Converts images of text into machine-encoded text for agent processing.
  • Prompt Formatting - Provides string classes for keyword substitution and advanced formatting in prompt generation.
  • Multi-Hop Question Generators - Provides automated pipelines for generating complex multi-hop question-answer pairs requiring multi-step logical reasoning.
  • Structured Prompting Tools - Creates structured descriptions and prompts from function definitions to guide agent tool selection.
  • Prompt-Based Schema Enforcement - Enforces structured data output from models using prompt engineering techniques to ensure compatibility with downstream workflows.
  • Text Summarization - Extracts and condenses relevant information from text blocks based on specific user queries.
  • Task Management - Generates and updates lists of pending tasks based on current objectives and the status of completed work.
  • Markdown Converters - Converts diverse document and media sources into unified markdown format for agentic workflows.
  • Content Extraction - Converts web content into structured formats using intelligent extraction for language model processing.
  • File Ingestion Services - Facilitates the ingestion of files by extracting text and metadata for searchable context.
  • Data Filtering - Scores generated content using reward models and discards entries that fail to meet quality thresholds.
  • Document and Unstructured Extraction - Parses complex documents and images using OCR to convert unstructured files into machine-readable formats.
  • DOM-to-Markdown Transformations - Automates the transformation of web content into LLM-ready markdown structures.
  • Data Transformation - Converts interaction logs into structured formats using language models and custom transformation schemas.
  • Knowledge Graph Construction Tools - Implements automated construction of knowledge graphs from unstructured documents to enable complex data querying.
  • PDF Parsers - Extracts structured text from PDF documents to enable agent-based analysis of complex files.
  • Real-Time Data Integration Platforms - Connects models to live external data sources to provide up-to-date information for decision-making.
  • Structured Data Extraction - Parses and normalizes specific data formats like code collections from unstructured text.
  • Dataset Record Structures - Organizes information into standardized records containing questions, answers, and reasoning to support agent training.
  • Web Data Extraction - Fetches and cleans website text into LLM-friendly formats by stripping unnecessary elements.
  • File System Operations - Manages file operations within restricted directories to ensure path safety during agent tasks.
  • Request Retries - Implements automatic retries with exponential backoff to handle API instability during agent operations.
  • Container Lifecycle Management - Automates the cleanup and lifecycle management of containers used for task execution.
  • Tool Use and Function Calling - Extracts function names and arguments from text strings to support complex tool-calling workflows.
  • Response Streaming Utilities - Streams partial message deltas incrementally to provide real-time feedback during long-running completions.
  • Built-ins - Provides a library of pre-built integrations for web browsing, code execution, and data retrieval.
  • Method Call Verification - Verifies the correctness of agent-generated function calls by comparing them against ground truth data.
  • Benchmarks - Provides standardized datasets used to evaluate and compare the performance of agent systems.
  • Language Model Requests - Enables adjustment of request parameters to control chat completion behavior and output format.
  • Browser Session Persistence - Preserves login states and session data across multiple runs to maintain browser-based automation context.
  • Protocol Adapters - Transforms internal toolkits into standard server protocols for broader compatibility across agent systems.
  • Web Crawling - Systematically discovers and extracts web content to serve as external knowledge for autonomous agents.

    • سجل النجوم

    مخطط تاريخ النجوم لـ camel-ai/camelمخطط تاريخ النجوم لـ camel-ai/camel

    بدائل مفتوحة المصدر لـ Camel

    مشاريع مفتوحة المصدر مشابهة، مرتبة حسب عدد الميزات المشتركة مع Camel.
    • letta-ai/lettaالصورة الرمزية لـ letta-ai

      letta-ai/letta

      21,168عرض على GitHub↗

      Letta is a framework for building, deploying, and managing autonomous AI agents that maintain persistent state across long-term interactions. It provides a comprehensive suite of primitives for defining agents with configurable personas, modular memory blocks, and tool-use capabilities, enabling them to retain user preferences and conversation history over extended sessions. The platform distinguishes itself through its advanced memory management and orchestration capabilities. It allows agents to autonomously update their own memory, perform retrieval-augmented generation, and coordinate com

      Pythonaiai-agentsllm
      عرض على GitHub↗21,168
    • openai/openai-agents-pythonالصورة الرمزية لـ openai

      openai/openai-agents-python

      27,191عرض على GitHub↗

      This project is a Python framework for building autonomous, event-driven agent systems. It provides a unified runtime for orchestrating multi-agent workflows, managing persistent conversation state, and executing code within secure, isolated sandbox environments. The framework is designed to handle complex task delegation, allowing agents to invoke other agents as tools while maintaining context across multi-turn interactions. The framework distinguishes itself through its deep integration with the Model Context Protocol, enabling agents to connect to external data sources and remote services

      Pythonagentsaiframework
      عرض على GitHub↗27,191
    • agentscope-ai/agentscopeالصورة الرمزية لـ agentscope-ai

      agentscope-ai/agentscope

      26,895عرض على GitHub↗

      Agentscope is a comprehensive toolkit for developing and orchestrating autonomous multi-agent systems. It provides a unified framework for building agents that can reason, execute tools, and manage memory, enabling the creation of complex, collaborative workflows where multiple specialized agents interact to solve multi-step objectives. The platform distinguishes itself through a robust orchestration engine that supports both sequential and concurrent agent pipelines. It utilizes a centralized event bus for real-time telemetry, allowing developers to track agent reasoning, tool usage, and sys

      Pythonagentchatbotlarge-language-models
      عرض على GitHub↗26,895
    • mervinpraison/praisonaiالصورة الرمزية لـ MervinPraison

      MervinPraison/PraisonAI

      5,592عرض على GitHub↗

      PraisonAI is an autonomous AI agent platform that coordinates multiple LLM-powered agents for research, planning, and execution of complex workflows. It functions as a multi-agent orchestration framework, a workflow builder, and a Model Context Protocol server, while also providing retrieval-augmented generation through vector knowledge bases. Agents can interact via CLI, web, or standardized protocols with sandboxed code execution. The platform distinguishes itself with a rich set of agent communication protocols, including A2A, REST, WebSocket, voice and telephony integration, and MCP, allo

      Pythonagentsaiai-agent-framework
      عرض على GitHub↗5,592
    عرض جميع البدائل الـ 30 لـ Camel→

    الأسئلة الشائعة

    ما هي وظيفة camel-ai/camel؟

    This project is a comprehensive framework for building and managing autonomous agent systems. It provides a unified architecture for orchestrating multi-agent societies, where specialized agents collaborate through roleplay to decompose and solve complex tasks. The system integrates language models with external environments, enabling agents to perform real-world actions through a standardized tool-calling abstraction layer.

    ما هي الميزات الرئيسية لـ camel-ai/camel؟

    الميزات الرئيسية لـ camel-ai/camel هي: Agentic LLM Frameworks, Multi-Agent Orchestration Frameworks, Agent Tool Integrations, Multi-Agent Systems, Model Abstraction Layers, Multi-Agent Orchestration, Multi-Agent Orchestrators, Agent State Persistence.

    ما هي البدائل مفتوحة المصدر لـ camel-ai/camel؟

    تشمل البدائل مفتوحة المصدر لـ camel-ai/camel: letta-ai/letta — Letta is a framework for building, deploying, and managing autonomous AI agents that maintain persistent state across… openai/openai-agents-python — This project is a Python framework for building autonomous, event-driven agent systems. It provides a unified runtime… agentscope-ai/agentscope — Agentscope is a comprehensive toolkit for developing and orchestrating autonomous multi-agent systems. It provides a… mervinpraison/praisonai — PraisonAI is an autonomous AI agent platform that coordinates multiple LLM-powered agents for research, planning, and… mastra-ai/mastra — Mastra is an orchestration framework designed for building, deploying, and managing autonomous AI agents and… i-am-bee/beeai-framework — The BeeAI Framework is an LLM agent framework and multi-agent orchestration engine used to build autonomous agents…