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

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

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

IBM/mcp-context-forge

0
View on GitHub↗
ibm.github.io/mcp-context-forge
↗

Mcp Context Forge

mcp-context-forge is a Model Context Protocol federation gateway that unifies diverse AI tool servers and APIs into a single consistent interface for discovery and execution. It acts as a centralized proxy that aggregates multiple servers and APIs, allowing AI agents to access and invoke a unified set of tools, prompts, and resources.

The project distinguishes itself through a multi-protocol translation bridge that converts communication between standard I/O, SSE, gRPC, and REST to enable interoperability between disparate tool servers. It includes a comprehensive LLM evaluation framework for assessing model output quality, safety, and grounding, alongside an AI tool governance platform that enforces role-based access control and content guardrails.

The system provides a broad surface of capabilities including AI agent observability via OpenTelemetry, enterprise identity integration through OIDC and SAML, and secure code execution within sandboxed environments. It also features extensive content management utilities for processing documents, spreadsheets, and code, as well as traffic management tools such as circuit breakers and rate limiting.

The project can be deployed using Helm charts for Kubernetes or via Docker Compose, with support for air-gapped installations.

Features

  • AI Tool Federation - Unifies diverse AI tool servers and APIs into a single consistent interface for agent discovery and execution.
  • MCP Gateway Federations - Acts as a centralized gateway that unifies multiple MCP servers and APIs for AI agent discovery and execution.
  • Aggregator Servers - Unifies multiple tools, APIs, and MCP servers into a single consistent interface for AI agent discovery.
  • AI Protocol Translation - Translates communication between local standard I/O servers and remote streaming HTTP endpoints using AI-specific context protocols.

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

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

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

Start searching with AI
3,310 نجوم·539 تفرعات·Python·apache-2.0·9 مشاهدات
  • Protocol Translation Bridges - Implements a translation bridge that converts communication between standard I/O, SSE, gRPC, and REST for tool server interoperability.
  • Agent Communication Interfaces - Normalizes requests and serializes responses to ensure consistent transport behavior and retry logic across agents.
  • Agent-to-Agent Communication - Implements standardized interfaces and metrics to facilitate communication between distributed AI agents.
  • Agent Framework Integrations - Connects various AI agent frameworks to a centralized registry for standardized access to tools and resources.
  • Tool Execution Monitoring - Tracks tool invocations, prompt rendering, and resource fetching, including detailed timing and execution results.
  • Agent Message Routing - Provides specialized dispatch logic to direct communication and requests between different AI agents.
  • Agent Registrations - Manages the registration of external agents by specifying their endpoint URLs and authentication credentials.
  • Custom Tool Registrations - Allows the definition of executable operations for APIs by specifying target URLs and input schemas for agent use.
  • AI Agent Orchestrators - Facilitates the integration and discovery of workflows involving multiple external AI agents through a centralized interface.
  • MCP Server Registrations - Connects external tool servers to a central gateway to enable unified discovery of available capabilities.
  • AI Agent Tool Integrations - Connects AI models to external software and APIs, enabling agents to call specific functions from a chat interface.
  • Multi-Protocol Tool Exposures - Exposes agent capabilities as tools compatible with multiple protocols, including MCP, REST, and gRPC.
  • AI Governance Tools - Implements an infrastructure layer for managing access control, role-based permissions, and security guardrails for AI tools.
  • AI Observability Tracing - Tracks distributed requests and LLM-specific metrics using OTLP backends to provide AI-specific observability.
  • Dynamic Tool Discovery - Fetches available tools and their schemas from remote servers in real-time without manual configuration.
  • External Agent Integrations - Integrates external agents via a standardized interface to allow discovery and remote invocation.
  • Federated Tool Execution - Invokes tools across different registered gateways through a single consistent interface for AI agents.
  • Agent-as-Tool Wrapping - Allows AI agents to be wrapped and exposed as standardized tools for use by other agents.
  • Prompt Management Systems - Defines and manages parameterized message templates to ensure consistency in system instructions for AI agents.
  • LLM Evaluation Frameworks - Implements a testing environment for assessing model output quality and grounding using automated evaluation suites.
  • LLM Provider Integrations - Manages connectivity and configuration for various AI model providers to control tool-calling behavior.
  • MCP Lifecycle Orchestration - Manages the full operational lifecycle of the MCP stack, from configuration validation to container deployment.
  • MCP Protocol Adapters - Translates REST APIs and gRPC services into compatible tools through automatic schema extraction.
  • Action Function Exposures - Exposes functions with JSON Schema definitions and authentication for seamless invocation by language models.
  • Resource Exposure - Provides a unified interface for exposing tools, prompts, and read-only data resources to AI agents.
  • Server Registries - Registers multiple servers and APIs into a single proxy to enable centralized discovery.
  • Tool Invocation Handlers - Executes tools from federated servers via HTTP endpoints using JSON payloads.
  • Tool Registries - Provides a centralized registry to track, discover, and verify available AI tools.
  • Tool-Use Proxies - Provides a proxy layer that handles the routing and execution of tool requests to remote servers.
  • Virtual API Wrappers - Wraps REST and gRPC services as MCP-compliant tools using automatic reflection and schema extraction.
  • Tool Access Governance - The project enforces RBAC and visibility filtering to restrict tool exposure to specific users.
  • AI Context Resource Management - Lists available data resources and reads specific content using unique URIs to provide context for agents.
  • Remote Function Execution - Executes custom functions on federated servers through a centralized gateway.
  • Tag-Based Search - Provides capabilities for retrieving specific tools or resources based on assigned metadata labels and tags.
  • Python Execution Sandboxes - Executes Python scripts in a protected environment using AST-level transformation and optional sandboxing.
  • Virtual Tool Conversions - Transforms REST-backed services into virtual servers and tools discoverable by AI agents.
  • gRPC Service Discovery - Automatically discovers gRPC services and converts them into compatible tools for AI agents.
  • Tool Execution Interfaces - Implements JSON-RPC endpoints that accept tool call requests with specific arguments and return execution results.
  • MCP Transport Protocol Supports - Supports sending requests via diverse transport protocols including JSON-RPC, streaming events, and standard I/O.
  • Stdio to SSE Translation - Translates standard I/O servers into streaming services to enable remote network access.
  • Protocol Client Integrations - Supports multiple communication protocols, including stdio and SSE, for connecting AI clients to federated tools.
  • Protocol Translation - Translates standard I/O servers into streaming endpoints to enable network-based registration with the proxy.
  • gRPC-to-MCP Converters - Translates gRPC services into MCP-compatible tools by converting Protobuf messages to JSON.
  • AI Tool Routing - Directs requests using MCP-specific logic and tool registries to ensure precise tool invocation.
  • Stdio Tunnels - Wraps standard input/output servers in a bridge to expose capabilities over the network via SSE.
  • Transport Bridges - Translates traffic between disparate transport layers like stdio, SSE, gRPC, and REST to enable tool server interoperability.
  • Sandboxed Code Execution Environments - Runs dynamic Python code in isolated contexts with AST transformations and resource limits.
  • Rust Runtime Accelerations - Increases throughput by moving the high-traffic data path to a high-performance Rust-based runtime.
  • Agentic - Governs AI tool access using user-scoped OAuth tokens, JWTs, and RBAC context.
  • Automatic Request Token Injection - Automatically retrieves stored user tokens and injects them as Bearer headers into forwarded upstream requests.
  • Centralized Governance Platforms - Enforces authentication, token scoping, and RBAC from a central authority across all protocol modules.
  • Enterprise Identity Providers - Integrates with external identity providers via OIDC and SAML to centralize enterprise authentication.
  • Identity and Access Management - Resolves caller identity and validates permissions to ensure users only access authorized tools and resources.
  • Bearer Token Authentication - Provides a unified authentication layer supporting JWT bearer tokens, Basic Auth, and email logins.
  • OAuth Authentication - Handles standard OAuth 2.0 Client Credentials and Authorization Code flows using bearer tokens and PKCE.
  • Role-Based Access Control - Enforces granular permissions and visibility levels across tools, resources, and prompts via role-based access.
  • Conditional Access Rules - Evaluates dynamic attributes and conditions to restrict plugin execution based on servers, tenants, and users.
  • User Identity Management - Manages user registration, authentication, and password complexity enforcement for the platform.
  • Natural Language Tool Interfaces - Provides a conversational interface where language models automatically select and execute tools using natural language descriptions.
  • MCP Tool Discovery Metadata - Exposes tool metadata including names and input schemas to enable discovery and invocation of federated tools.
  • AI Agent Observability - Instruments tool invocations and prompt rendering with distributed tracing and metrics via OpenTelemetry.
  • LLM Performance Monitoring - Tracks token usage, API costs, and response quality to identify model drift and monitor LLM performance.
  • OpenTelemetry-Integrated Monitors - Integrates with OpenTelemetry and Prometheus to export distributed traces and system metrics.
  • LLM Evaluation - Provides a framework for testing model output quality, safety, and grounding using automated suites and LLM-as-a-judge.
  • Agentic API Translation - Converts conversational requests into structured API calls and formats resulting data for AI consumption.
  • Assistant Lifecycle Management - Manages the registration and state of agent-to-agent assistants and their associated toolsets.
  • Agent Evaluation Tools - Assesses the reasoning chains, tool selection patterns, and output quality of autonomous AI agents.
  • CLI Process Wrapping - Wraps arbitrary command-line interfaces and subprocesses as AI agents by managing standard I/O streams.
  • Agent Prompt Templates - Defines and manages reusable system prompt structures to standardize interactions and control agent behavior.
  • OpenAI-Compatible APIs - Exposes standard chat completion endpoints to act as a unified provider for internal services using the OpenAI API format.
  • Connection Pooling - Maintains persistent connections to upstream servers to reduce latency for repeated tool calls.
  • AI Knowledge Management - Creates and stores named content in Markdown or JSON to provide context for AI agents.
  • Prompt Evaluation Tools - Detects ambiguity in prompts and tests output consistency across multiple runs to optimize prompt engineering.
  • Prompt Template Retrieval - Lists available templates and fetches specific prompts with arguments for AI agents.
  • AI Safety Guardrails - Detects and redacts PII and filters content using moderation models to ensure AI safety.
  • Document Grounding - Verifies that AI-generated responses are strictly grounded in retrieved source documents and adhere to instructions.
  • Execution Interception Hooks - Modifies prompts and tool calls via execution hooks to implement safety and validation guardrails.
  • Server Connection Managers - Establishes real-time connections to virtual servers using Server-Sent Events for data streaming.
  • External Service Integrations - Connects to remote plugin services to offload complex inference tasks or enforce security policies.
  • RAG Pipeline Integrations - Wraps external tool calls as query engines or retrievers to provide agents with external grounding data.
  • Gateway Management - Provides administrative control over gateways that connect the system to external tool servers.
  • LLM Gateways - Acts as a centralized gateway exposing an OpenAI-compatible interface for internal LLM endpoints.
  • Model Comparison Interfaces - Provides analytical and side-by-side comparison of outputs generated by different model versions to identify superior performance.
  • Adversarial Robustness Testing - Evaluates model stability and security by executing adversarial attacks and stability checks across input variations.
  • Conversational Interfaces - Provides a conversational interface for AI agents to select and execute available tools using various language model providers.
  • MCP Server Synchronizations - Synchronizes tools and resources from remote compatible servers into a centralized local catalog.
  • Middleware Extensions - Interposes middleware components into MCP and agentic flows for security and observability.
  • Transport Configurations - Configures high-performance communication protocols for connectivity between the gateway and its plugins.
  • Invocation Rate Limits - Caps the number of requests clients can make to a specific tool within a time window.
  • Evaluation Tool Exposure - Serves LLM evaluation capabilities through the gateway with integrated health monitoring across multiple transport layers.
  • Model Provider Adapters - Standardizes streaming behavior and deadlines across diverse AI model providers for consistent integration.
  • Prompt Templates - Creates and stores prompt templates and executes them by providing arguments.
  • Semantic Chunking - Divides text into meaningful segments based on semantic boundaries and markdown headers to optimize context windows.
  • Virtual Entity Exposure - Groups specific tools into a virtual entity to provide a unified endpoint for AI agents.
  • AI Safety Auditing - Identifies demographic bias, detects harmful content, and scans for personally identifiable information.
  • Tool Execution Visualizations - Visualizes invocation latency and success rates of AI tools to identify performance bottlenecks.
  • Structural Code Parsers - Parses source code using ASTs to split files into functions, classes, and methods.
  • Natural Language Data Queries - Translates natural language questions into executable pandas code for statistical analysis of CSV files.
  • Entity Registries - Maintains a relational database catalog of registered entities and configuration to ensure persistence across restarts.
  • Tool Result Caching - Stores tool responses and prompt-based results to reduce latency and eliminate redundant computation.
  • Strict Tool Argument Validators - Enforces strict JSON Schema validation for tool arguments during registration.
  • Read-Only Resource Exposure - Exposes text or binary data via unique URIs for retrieval by AI models.
  • Code Context Retrieval - Retrieves real-time configurations and code snippets to provide current context for AI assistants.
  • Session State Management - Tracks session ownership and event history to enable the replay and resumption of AI-driven tasks.
  • Hybrid Runtimes - Utilizes a native Rust implementation for high-traffic data paths to increase request throughput over Python.
  • Plugin Lifecycle Management - Handles the discovery, loading, and runtime control of both native and remote external plugins.
  • Request Processing Plugins - Executes a chain of modular filters for rate limiting and response transformation during request processing.
  • API Specification Importers - Creates gateway records by importing API specifications or using reflection-style discovery.
  • MCP Protocol Debugging - Provides a visual interface to invoke functions and inspect JSON-RPC messages for diagnosing MCP protocol issues.
  • API Traffic Management - Provides centralized control over API stability through rate-limiting, retry policies, and timeout settings.
  • Traffic Control - Provides traffic control mechanisms including retry policies and circuit breakers to ensure backend stability.
  • Declarative Configuration Files - Automates server registration and categorization through declarative YAML configuration files.
  • Dynamic Code Safety Analysis - Analyzes Python code before execution to detect restricted operations and imports for secure sandboxing.
  • API Token Management - Issues and revokes scoped API tokens with restrictions on servers, IP ranges, and usage quotas.
  • Virtual Tool Composition - Groups multiple servers and tools into a single unified service endpoint for simplified access.
  • Worker Process Management - Spawns multiple worker processes to bypass the GIL and utilize all available CPU cores for higher throughput.
  • API Client Integrations - Provides standardized interfaces for external applications and plugins to consume federated AI tools.
  • API Request Proxying - Maps tool parameters to query strings and headers to proxy requests to upstream REST APIs.
  • Chat Session Managers - Tracks state and coordinates models over persistent connections for session-oriented AI interactions.
  • MCP-to-Stdio Proxies - Translates remote server communication into local standard input/output streams for GUI clients.
  • Networked Stdio Exposures - Translates network-based APIs into standard input/output streams for clients without network support.
  • Middleware-Based Request Pipelines - Implements a modular chain of pluggable components to intercept and process network requests and responses.
  • gRPC Microservices Integration - Integrates external plugins using a high-performance gRPC transport layer with secure encryption.
  • Model Request Proxies - Relays requests through a unified interface to route and coordinate multiple interchangeable language model providers.
  • Multi-Transport Server Architectures - Provides connectivity for tools via streaming HTTP for remote access and standard I/O for local development.
  • Multi-Protocol Routing - Routes requests through a centralized catalog and dispatches them to the appropriate runtime module across different protocols.
  • Transport Identification - Identifies communication protocols by analyzing server URLs or explicit configurations.
  • Host Allowlisting - Uses a host allowlist to limit which upstream schemes and hostnames tools can connect to.
  • Stdio to SSE Bridges - Bridges standard input/output servers to streaming events to make them accessible via HTTP.
  • Circuit Breakers - Implements circuit breakers to stop traffic to failing tool servers and prevent cascading failures.
  • Traffic Protocol Inspection - Displays a real-time bidirectional log of JSON-RPC messages between clients and servers for protocol inspection.
  • Multi-Transport Endpoints - Routes requests across diverse communication patterns through a single unified service layer.
  • Virtual Server Orchestration - Composes multiple tools into a single virtual server accessible via streaming events.
  • Plugin Lifecycle Hooks - Runs custom logic before and after tool invocations via a specialized plugin framework.
  • AST-Validated Sandboxes - Implements an isolated execution environment that uses AST analysis to block dangerous Python operations.
  • Tool Interaction Auditing - Generates structured, immutable audit logs with identity attribution for every tool interaction.
  • AI Content Filters - Integrates with moderation services like LlamaGuard to mask PII and prevent prompt injection attacks.
  • Hardened Container Images - Provides a secure, non-root runtime image based on RHEL UBI for hardened deployments.
  • Team-Scoped Visibility Controls - Provides multi-level resource visibility including public, team-scoped, and private access levels.
  • Service Account Authorization - Uses domain-wide delegation and service accounts to secure server-to-server authentication.
  • Identity Propagation - Forwards authenticated user details to upstream servers via HTTP headers to enable downstream authorization.
  • SSO Integrations - Integrates with Keycloak via OpenID Connect for centralized identity and access management.
  • Input Sanitization - Scans incoming data for XSS, SQL injection, and command injection patterns to prevent attacks.
  • JWT Authentication - Validates user identity using symmetric or asymmetric JSON Web Tokens with audience and issuer verification.
  • AI Agent Tenant Isolation - Ensures multi-tenant security through team-scoped catalogs and isolated secret stores for AI agents.
  • OAuth Scope Restrictions - Limits token permissions to specific servers or API actions to enforce the principle of least privilege.
  • Client Request Quotas - Enforces per-client request quotas to protect backend tool server capacity from exhaustion.
  • Custom Role Definitions - Bootstraps predefined roles with specific permission sets using JSON configuration.
  • SCIM Provisioning - Automates user provisioning and attribute synchronization utilizing the SCIM protocol.
  • Secret Encryption - Protects tool credentials and OAuth tokens in the database using AES-GCM and Fernet encryption.
  • Secret Management Integrations - Integrates with external secret stores to securely inject credentials into the system runtime.
  • PII Masking - Intercepts tool invocations to mask PII such as emails and credit cards before requests reach backend servers.
  • Single Sign-On Integrations - Enables enterprise identity management and single sign-on through Microsoft Entra ID integration.
  • SSRF Protections - Blocks requests to internal resources and cloud metadata services using DNS validation to prevent SSRF.
  • TLS Transfer Security - Configures SSL/TLS and mTLS authentication to ensure encrypted data transfer for the Model Context Protocol.
  • Tool Namespace Prefixes - Groups tools into namespaces using prefixes to prevent naming collisions across federated servers.
  • Backpressure Coordination - Prevents system overload by rejecting excess incoming requests with 503 responses when capacity is reached.
  • Distributed State Synchronization - Synchronizes session and runtime state across distributed server instances to support multi-pod deployments.
  • Remote Server Registrations - Registers reverse-proxied servers into a central catalog to be treated as native servers.
  • JSON Schema Validation - Enforces strict specification compliance for tools and prompts during registration using JSON schema validation.
  • Resource Registration - Associates data sources with unique URIs and MIME types for discovery and access.
  • Agent Health Monitoring - Tracks protocol-specific metrics and runtime health to ensure the availability of connected AI agents.
  • Application Metric Tracking - Tracks response latency, computational efficiency, and translation quality across multiple languages.
  • Authentication Event Auditing - Logs authentication attempts and administrative changes to maintain a verifiable audit trail for compliance.
  • Observability Data Emission - Publishes structured logs, counters, and audit events to a centralized system for comprehensive observability.
  • Prometheus-Based Metric Exporters - Exposes a dedicated metrics endpoint to export system performance and request rates in Prometheus format.
  • Request Correlation - Propagates unique correlation IDs through middleware to link events across a single distributed request.
  • System Health Dashboards - Provides interactive dashboards with performance charts to monitor operational status and identify error-prone resources.
  • Flame Graph Generators - Renders operation timings and call hierarchies using flame graphs and Gantt charts for performance analysis.
  • LLM-As-A-Judge Scoring - Assesses model outputs using a high-capability language model acting as a judge based on defined rubrics.
  • Response Quality Scoring - Scores generated responses using custom evaluators to measure overall quality and computational cost.
  • AI Evaluation Suites - Executes comprehensive batches of quality, safety, and performance tests to generate model readiness reports.
  • Pluggable Cache Backends - Supports pluggable cache backends like Redis or in-memory stores for frequently accessed authentication and tool lookups.
  • Request Lifecycle Hooks - Executes custom logic during critical phases of prompt fetching, tool invocation, and resource retrieval.
  • OpenAPI Publishing - Exposes a type-safe API contract as an OpenAPI-compliant REST interface for external tool discovery.

    • سجل النجوم

    مخطط تاريخ النجوم لـ ibm/mcp-context-forgeمخطط تاريخ النجوم لـ ibm/mcp-context-forge

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

    ما هي وظيفة ibm/mcp-context-forge؟

    mcp-context-forge is a Model Context Protocol federation gateway that unifies diverse AI tool servers and APIs into a single consistent interface for discovery and execution. It acts as a centralized proxy that aggregates multiple servers and APIs, allowing AI agents to access and invoke a unified set of tools, prompts, and resources.

    ما هي الميزات الرئيسية لـ ibm/mcp-context-forge؟

    الميزات الرئيسية لـ ibm/mcp-context-forge هي: AI Tool Federation, MCP Gateway Federations, Aggregator Servers, AI Protocol Translation, Protocol Translation Bridges, Agent Communication Interfaces, Agent-to-Agent Communication, Agent Framework Integrations.

    ما هي البدائل مفتوحة المصدر لـ ibm/mcp-context-forge؟

    تشمل البدائل مفتوحة المصدر لـ ibm/mcp-context-forge: langchain-ai/deepagents — Deepagents is an LLM agent orchestration platform and stateful application server designed for deploying and managing… prefecthq/fastmcp — FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models… agenta-ai/agenta — Agenta is a Prompt Ops lifecycle manager and prompt management platform that decouples prompt engineering from… kilo-org/kilocode — Kilocode is an autonomous engineering platform designed to orchestrate AI agents for complex software development… maiot-io/zenml — ZenML is an extensible machine learning orchestration framework designed to manage the end-to-end lifecycle of data… mastra-ai/mastra — Mastra is an orchestration framework designed for building, deploying, and managing autonomous AI agents and…

    بدائل مفتوحة المصدر لـ Mcp Context Forge

    مشاريع مفتوحة المصدر مشابهة، مرتبة حسب عدد الميزات المشتركة مع Mcp Context Forge.
    • langchain-ai/deepagentsالصورة الرمزية لـ langchain-ai

      langchain-ai/deepagents

      25,006عرض على GitHub↗

      Deepagents is an LLM agent orchestration platform and stateful application server designed for deploying and managing AI agents built with computational graphs. It provides a containerized runtime environment that handles agent execution, state persistence, and the versioning of AI assistants. The platform distinguishes itself through deep integration with the Model Context Protocol, allowing agents to function as servers that expose tools and capabilities to external clients. It features a sophisticated observability suite for capturing execution traces, performing LLM-based evaluations agai

      Pythonagentsdeepagentslangchain
      عرض على GitHub↗25,006
    • prefecthq/fastmcpالصورة الرمزية لـ PrefectHQ

      PrefectHQ/fastmcp

      22,994عرض على GitHub↗

      FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models using the Model Context Protocol. It simplifies the development process by automatically deriving tool metadata, input schemas, and documentation directly from Python function signatures and type hints. The framework provides a unified container for managing these components, allowing developers to build modular applications that integrate seamlessly with AI assistants. The project distinguishes itself through its support for interactive, server-defined user interface compone

      Pythonagentsfastmcpllms
      عرض على GitHub↗22,994
    • agenta-ai/agentaالصورة الرمزية لـ Agenta-AI

      Agenta-AI/agenta

      3,860عرض على GitHub↗

      Agenta is a Prompt Ops lifecycle manager and prompt management platform that decouples prompt engineering from application code. It serves as a centralized system for developing, versioning, and deploying prompt templates and model configurations across different environments. The platform functions as an AI agent orchestrator with a visual interface for building agent workflows and connecting models to external tools. It further acts as an evaluation framework and observability tool, utilizing OpenTelemetry to capture execution traces, monitor latency, and track token costs. The system cove

      TypeScriptagentsevaluationllm-as-a-judge
      عرض على GitHub↗3,860
    • kilo-org/kilocodeالصورة الرمزية لـ Kilo-Org

      Kilo-Org/kilocode

      15,616عرض على GitHub↗

      Kilocode is an autonomous engineering platform designed to orchestrate AI agents for complex software development tasks. It functions as a comprehensive system for automating coding, testing, and repository management by integrating directly with your codebase and terminal. The platform provides a unified gateway for model orchestration, allowing for the management of agentic workflows, event-driven automation, and persistent session state across distributed development environments. The platform distinguishes itself through its federated task management and policy-based access control, which

      TypeScriptaiai-ageai-coding
      عرض على GitHub↗15,616
    عرض جميع البدائل الـ 30 لـ Mcp Context Forge→