AgentProject - AI-Powered Intelligent Agent Platform

A professional-grade AI agent framework built with .NET 8.0 and React, designed for autonomous task execution and intelligent workflow automation. All files and solution logic are generated from Manus. reference: https://manus.im/ About to be abandoned

📢 Author's Message

This project is continuously being optimized, and the author strives for 3+ updates and optimizations per week.

C# never lost online, never won in reality. Man! what can i say? 🚀

2026-02-01 Reminder

Due to Manus' recent reduction of key functions and the increasingly serious problems exposed in its Reddit community, the author's expectations for Manus have been declining.

Because it has become more oriented towards non-professional users, both the loopholes in the payment system and the efficiency of integrating the model for project modifications have become increasingly poor. I began to miss the version that was released not long ago.

This has forced the author to rethink and switch to more professional platforms and tools such as Cursor / Claude Code / Antigravity / Codex in order to continue the project.

Not only this was disappointing:

中文版本

🎯 Project Overview

AgentProject is an enterprise-grade AI agent framework that combines cutting-edge Large Language Model (LLM) technologies with robust backend infrastructure and intuitive frontend interfaces. The platform enables autonomous task execution through intelligent workflow management, Retrieval-Augmented Generation (RAG), and sandbox-based task processing.

Key Highlights

🤖 Multi-Model Support: Integration with OpenAI, DeepSeek, Kimi, and Llama 4, supporting both open-source and closed-source models
🏗️ Distributed Architecture: Native support for Kubernetes and Docker, inherently scalable
🔒 Advanced Security: eBPF system monitoring, ASP.NET Core Identity integration, fine-grained access control
⚡ Real-time Communication: SignalR enables instant updates and push notifications
📊 Enterprise-Ready: Comprehensive logging, distributed tracing, and observability
🎨 Modern UI: Dark theme support with intuitive workflow visualization

✨ Key Features

🤖 AI & LLM Capabilities

Semantic Kernel Integration - Unified LLM abstraction layer supporting multiple model providers (OpenAI, DeepSeek, Kimi, Llama 4)
Model Context Protocol (MCP) - Standardized tool integration framework for seamless AI tool interoperability
Retrieval-Augmented Generation (RAG) - Intelligent knowledge base with ChromaDB and custom vector store integration
Advanced Prompt Engineering - Prompt system with dynamic variable substitution and template management
Model Fine-tuning Tools - Complete scripts and utilities for custom model adaptation with MLflow tracking

⚙️ Workflow & Automation

Intelligent Workflow Engine - Orchestration and execution of complex multi-step tasks
Workflow Visualization - Visual workflow editor with drag-and-drop interface
Sandbox Terminal Integration - Secure isolated command execution environment preventing malicious operations
Dynamic Task Planning - AI-driven automatic to-do list generation and task decomposition
Flexible Interaction Handling - Support for interaction patterns across diverse task types

🔐 System & Security

eBPF Detection Module - Low-level system monitoring and security threat analysis
Identity & Authorization - Complete ASP.NET Core Identity implementation
Custom Policy Engine - Fine-grained role and permission management
Web Search Integration - Real-time information retrieval via SearXNG and SerpApi

📈 Observability & Operations

Agent Trace - Distributed tracing for AI agent execution flows with OpenTelemetry
Distributed Tracing - OpenTelemetry integration for end-to-end request visualization
Prometheus Metrics - Comprehensive application and system health metrics
MLflow Experiment Management - Model training and experiment tracking
Structured Logging - Correlation IDs and contextual logging across the call stack

🚀 Infrastructure & Deployment

Docker Containerization - Complete Docker Compose multi-container orchestration solution
Kubernetes Support - Helm charts and raw manifests for cloud deployment
YARP Reverse Proxy - Intelligent gateway with circuit breaker pattern support
High Availability Design - Load balancing and failover mechanisms

🛠 Technology Stack

📱 Backend Technologies

Component	Version	Purpose
.NET	8.0+	Modern high-performance web framework
ASP.NET Core	8.0+	Web API and real-time communication
Entity Framework Core	8.0+	PostgreSQL ORM mapping
SignalR	8.0+	Real-time bidirectional communication
Autofac	Latest	Advanced dependency injection container
OpenTelemetry	Latest	Observability and distributed tracing
Semantic Kernel	Latest	LLM abstraction and orchestration
YARP	Latest	Reverse proxy and gateway

🎨 Frontend Technologies

Component	Version	Purpose
React	18.0+	Modern UI framework
TypeScript	5.0+	Type-safe JavaScript development
SignalR Client	8.0+	Real-time notification client
Tailwind CSS	Latest	Modern CSS framework
Theme System	Built-in	Light/Dark theme switching

💾 Data & Storage

Component	Purpose
PostgreSQL 12+	Primary relational database for metadata storage
ChromaDB	Vector database supporting RAG functionality
Redis (Optional)	Caching layer for improved query performance

🐳 Containerization & Orchestration

Component	Purpose
Docker	Application and service containerization
Docker Compose	Local development multi-container orchestration
Kubernetes 1.21+	Production cloud deployment
Helm 3.0+	Kubernetes package management and templating

📊 Monitoring & Operations

Component	Purpose
Prometheus	Metrics collection and storage
Grafana (Optional)	Metrics visualization dashboard
MLflow	Machine learning experiment tracking
Elasticsearch (Optional)	Log indexing and search

🔗 Integration & Extensions

Component	Purpose
Model Context Protocol (MCP)	Standardized tool integration framework
Nginx	Web server and load balancing
SearXNG / SerpApi	Web search integration

🏗 System Architecture

Layered Architecture Design (Layered Architecture Pattern)

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃                      Layer 1: Presentation                          ┃
┃  ┌─────────────────────────────────────────────────────────────┐   ┃
┃  │  React 18+ Application Interface (agent-ui)                 │   ┃
┃  │  ┌──────────────────┐  ┌──────────────────┐  ┌──────────┐  │   ┃
┃  │  │  Dashboard       │  │  Workflow        │  │  Task    │  │   ┃
┃  │  │  - Analytics     │  │  - Editor        │  │  - Board │  │   ┃
┃  │  │  - Overview      │  │  - Visualizer    │  │  - Cards │  │   ┃
┃  │  └──────────────────┘  └──────────────────┘  └──────────┘  │   ┃
┃  └─────────────────────────────────────────────────────────────┘   ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                                  ↕                                   
                      HTTP/HTTPS + WebSocket                          
                                  ↕                                   
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃                    API Gateway Layer                                ┃
┃              (Nginx / YARP - Load Balancing)                        ┃
└─────────────────────────────┬───────────────────────────────┘       
                              │                                       
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃         Business Logic Layer (Application Layer)              ┃
┃                    ASP.NET Core Backend                       ┃
┃                                                                ┃
┃  ┌──────────────────────────────────────────────────────┐   ┃
┃  │  Agent.Api (Startup, Configuration, Routing)         │   ┃
┃  │  ├─ Program.cs: App Entry Point & DI Setup           │   ┃
┃  │  ├─ GlobalUsings.cs: Global Namespaces               │   ┃
┃  │  ├─ Controllers: REST API Routes                     │   ┃
┃  │  └─ Extensions: Modular Service Registration         │   ┃
┃  └──────────────────────────────────────────────────────┘   ┃
┃                                                                ┃
┃  ┌──────────────────────────────────────────────────────┐   ┃
┃  │  Agent.Application (Application Orchestration)       │   ┃
┃  │  ├─ DTOs: Request/Response Data Transfer Objects     │   ┃
┃  │  ├─ Mappers: Entity-DTO Mapping Logic                │   ┃
┃  │  ├─ Validators: Business Rule Validation             │   ┃
┃  │  ├─ Commands: CQRS Command Handling                  │   ┃
┃  │  ├─ Queries: CQRS Query Handling                     │   ┃
┃  │  ├─ Events: Domain Events Definition                 │   ┃
┃  │  └─ Behaviors: Pipeline Behaviors & Intercepting     │   ┃
┃  └──────────────────────────────────────────────────────┘   ┃
┃                                                                ┃
┃  ┌──────────────────────────────────────────────────────┐   ┃
┃  │  Agent.Core (Core Business Logic - Domain Layer)     │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Identity & Authorization                          │   ┃
┃  │    ├─ Authorization Handlers (Roles/Policies/Claims) │   ┃
┃  │    ├─ Authorization Policies (Permission Rules)      │   ┃
┃  │    └─ Identity Services (User/Role Management)       │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Workflow & Task Management                        │   ┃
┃  │    ├─ WorkflowService (Workflow Orchestration)       │   ┃
┃  │    ├─ TaskService (Task Management)                  │   ┃
┃  │    ├─ StateManager (State Tracking)                  │   ┃
┃  │    └─ ExecutionContext (Execution Context)           │   ┃
┃  │                                                       │   ┃
┃  │  ▶ System Monitoring & Detection                     │   ┃
┃  │    ├─ eBPF Services (Process Monitoring)             │   ┃
┃  │    ├─ SecurityDetector (Threat Detection)            │   ┃
┃  │    └─ HealthChecker (Health Checking)                │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Data Access & Persistence                         │   ┃
┃  │    ├─ Entity Models (Data Entities)                  │   ┃
┃  │    ├─ DbContext (EF Core Context)                    │   ┃
┃  │    ├─ Repositories (Generic Repository Pattern)      │   ┃
┃  │    └─ Migrations (Database Migrations)               │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Real-Time Communication                           │   ┃
┃  │    ├─ SignalR Hubs (Real-time Message Push)          │   ┃
┃  │    ├─ NotificationService (Notification Service)     │   ┃
┃  │    └─ ConnectionManager (Connection Management)      │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Gateway & Routing                                 │   ┃
┃  │    ├─ YARP Configuration (YARP Setup)                │   ┃
┃  │    ├─ RouteService (Routing Service)                 │   ┃
┃  │    └─ CircuitBreaker (Circuit Breaker Pattern)       │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Exception & Logging                               │   ┃
┃  │    ├─ Exception Handlers (Exception Handling)         │   ┃
┃  │    ├─ Logging Middleware (Logging Middleware)        │   ┃
┃  │    └─ Correlation ID (Correlation ID)                │   ┃
┃  └──────────────────────────────────────────────────────┘   ┃
┃                                                                ┃
┃  ┌──────────────────────────────────────────────────────┐   ┃
┃  │  Agent.McpGateway (AI Orchestration Engine)          │   ┃
┃  │                                                       │   ┃
┃  │  ▶ LLM Integration & Management                      │   ┃
┃  │    ├─ SemanticKernelService (SK Wrapper)             │   ┃
┃  │    ├─ ModelRouter (Model Routing)                    │   ┃
┃  │    ├─ PluginManager (Plugin Management)              │   ┃
┃  │    └─ PromptOptimizer (Prompt Optimization)          │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Knowledge Base & RAG                              │   ┃
┃  │    ├─ RagService (RAG Core Service)                  │   ┃
┃  │    ├─ DocumentProcessor (Document Processing)        │   ┃
┃  │    ├─ EmbeddingGenerator (Vector Generation)         │   ┃
┃  │    ├─ VectorDatabaseService (Vector DB Operations)   │   ┃
┃  │    └─ SimilaritySearcher (Similarity Search)          │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Workflow Orchestration                            │   ┃
┃  │    ├─ WorkflowService (Workflow Engine)              │   ┃
┃  │    ├─ WorkflowVisualization (Visual Editor Backend)  │   ┃
┃  │    ├─ WorkflowExecutor (Executor)                    │   ┃
┃  │    ├─ WorkflowParser (Parser)                        │   ┃
┃  │    └─ StateManager (State Management)                │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Prompt Engineering                                │   ┃
┃  │    ├─ PromptService (Prompt Management)              │   ┃
┃  │    ├─ TemplateEngine (Template Engine)               │   ┃
┃  │    ├─ VariableResolver (Variable Resolution)         │   ┃
┃  │    └─ PromptCache (Prompt Caching)                   │   ┃
┃  │    └─ ToolCallEnhancer (Tool Call Reliability)       │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Sandbox & Isolated Execution                      │   ┃
┃  │    ├─ SandboxService (Sandbox Service)               │   ┃
┃  │    ├─ ProcessExecutor (Process Execution)            │   ┃
┃  │    ├─ EnvironmentManager (Environment Management)    │   ┃
┃  │    └─ SecurityManager (Security Isolation)           │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Search & Integration                              │   ┃
┃  │    ├─ WebSearchService (Web Search)                  │   ┃
┃  │    ├─ CacheWarmupService (Intelligent Cache Preload) │   ┃
┃  │    ├─ McpTools (MCP Tools)                           │   ┃
┃  │    ├─ FileUploadService (File Management)            │   ┃
┃  │    └─ UserInputService (User Input)                  │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Model Fine-Tuning                                 │   ┃
┃  │    ├─ FinetuneService (Fine-tuning Service)          │   ┃
┃  │    ├─ MeteringService (Usage Tracking & Billing)     │   ┃
┃  │    ├─ DatasetPreparer (Dataset Preparation)          │   ┃
┃  │    ├─ ModelTrainer (Model Training)                  │   ┃
┃  │    └─ MetricsCalculator (Metrics Calculation)        │   ┃
┃  │                                                       │   ┃
┃  │  ▶ Observability                                     │   ┃
┃  │    ├─ AgentTraceService (Agent Execution Tracing)    │   ┃
┃  │    ├─ TelemetryService (Telemetry Service)           │   ┃
┃  │    ├─ MetricsCollector (Metrics Collection)          │   ┃
┃  │    └─ TraceExporter (Trace Exporting)                │   ┃
┃  └──────────────────────────────────────────────────────┘   ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                                  ↕                                   
          ┌───────────────────────┼───────────────────┐               
          │                       │                   │               
    ┌─────▼──────┐        ┌──────▼─────┐    ┌─────▼──────┐            
    │ PostgreSQL │        │  ChromaDB   │    │ External   │            
    │ (Metadata) │        │  (Vectors)  │    │ Services   │            
    │            │        │             │    │            │            
    │ - Users    │        │ - Embeddings│    │ - OpenAI   │            
    │ - Workflows│        │ - Documents │    │ - DeepSeek │            
    │ - Tasks    │        │ - RAG Index │    │ - Kimi     │            
    │ - Config   │        │             │    │ - Llama 4  │            
    └────────────┘        └─────────────┘    │ - SearXNG  │            
                                              └────────────┘

Architecture Characteristics

📌 Separation of Concerns

Single responsibility per layer, clear boundaries
Dependencies flow from top to bottom
Each layer independently testable and maintainable

🔄 Data Flow

Request Flow: Presentation → Gateway → Application → Business → Data → Storage
Response Flow: Storage → Data → Business → Application → Gateway → Presentation
Notification Flow: SignalR Hub → Gateway → Presentation (Real-time Push)

🛡️ Cross-Cutting Concerns

Authentication/Authorization: Enforced at gateway and business layers
Logging/Tracing: Collected across all layers
Error Handling: Unified handling at gateway layer
Caching: Implemented at data layer

💻 System Requirements

Minimum Hardware Configuration

CPU:     4 cores (8+ cores recommended)
Memory:  8 GB (16+ GB recommended)
Storage: 50 GB SSD (100+ GB recommended)
Network: Stable 1Mbps+ network connection

Software Dependencies

Required Components

.NET SDK         8.0.0 or higher
Node.js          16.x or higher
npm / yarn       7.0+ or 1.22.x+
Docker           20.10+ (for containerized deployment)
Docker Compose   1.29+ (for container orchestration)
PostgreSQL       12.x or higher
Git              2.20+

Optional Components

Kubernetes       1.21+ (for cloud deployment)
Helm             3.0+ (for Kubernetes package management)
NVIDIA CUDA      11.0+ (for GPU acceleration)
Prometheus       Latest (for monitoring)
MLflow           Latest (for experiment tracking)
Elasticsearch    7.0+ (for log analysis)
Redis            6.0+ (for caching)

Network Requirements

- Network connectivity to various LLM service providers
- Firewall rules allowing:
  * Port 3000 (Frontend)
  * Port 5000 (Backend API)
  * Port 5432 (PostgreSQL)
  * Port 8000 (ChromaDB)
  * Port 9090 (Prometheus)

📁 Project Structure

apps/ - Application Code

apps/
├─ agent-api/                         # 🔧 Backend API Services
│  ├─ Agent.Api/                      # 🎯 Application Startup & Configuration
│  ├─ Agent.Application/              # 💼 Application Orchestration Layer
│  ├─ Agent.Core/                     # 💎 Core Business Logic
│  └─ Agent.McpGateway/               # 🤖 AI Orchestration Engine
│
├─ agent-ui/                          # 🎨 React Frontend Application
│  ├─ public/                         # 📊 Static Assets
│  └─ src/                            # 💻 Source Code
│     ├─ components/                  # 🧩 Reusable UI Components
│     ├─ pages/                       # 📄 Application Pages
│     ├─ services/                    # 🔌 API Services
│     ├─ hooks/                       # ⚛️ Custom React Hooks
│     ├─ store/                       # 🗄️ State Management
│     ├─ styles/                      # 🎨 CSS Styles
│     ├─ utils/                       # 🛠️ Utility Functions
│     └─ types/                       # 📋 TypeScript Types
│
├─ agent-ops-ui/                      # 📈 Operations & Monitoring UI
│  └─ ...                             # Dashboard for system metrics
│
├─ agent-ops/                         # 🔍 Operational Services
│  └─ Agent.Metering/                 # 📊 Usage Metering & Billing
│
└─ agent-tools/                       # 🛠️ Utility Tools & Scripts
    └─ ...                            # Python-based tool collection

docs/ - Documentation

docs/
├─ agent-ui_dependency_summary.md     # 📋 Agent UI Dependencies
├─ api_documentation.md               # 📚 API Documentation
├─ chromadb_integration.md            # 🔍 ChromaDB Setup Guide
├─ clickhouse_integration.md          # 💾 ClickHouse Integration
├─ deepo_unsloth_cuda_setup.md        # 🎓 Deepo & Unsloth CUDA Setup
├─ docker_quickstart.md               # 🐳 Docker Quick Start
├─ dynamic_external_access.md         # 🌐 Dynamic External Access
├─ ebpf_integration.md                # 🔒 eBPF Security Module
├─ environment_setup.md               # ⚙️ Environment Configuration
├─ github_upload.md                   # 📤 GitHub Upload Guide
├─ grafana_integration.md             # 📊 Grafana Dashboard Setup
├─ harbor_installation.md             # 🏗️ Harbor Registry Installation
├─ helm_installation.md               # ⎈ Helm Charts Guide
├─ identity_signalr_integration.md    # 🔐 Auth & Real-time Comm
├─ kubernetes_istio_grayscale_release.zh_CN.md  # ☸️ K8s Deployment
├─ mcp_integration_guide.zh_CN.md     # 🔌 MCP Integration
├─ mlflow_integration.md              # 📈 MLflow Experiment Tracking
├─ openmanus_integration.md           # 🤖 OpenManus Integration
├─ prometheus_integration.md          # 📉 Prometheus Monitoring
├─ rag_prompt_engineering.md          # 🤖 RAG & Prompt Engineering
├─ sandbox_terminal_integration.md    # 🔒 Sandbox Environment
├─ semantic_kernel_examples.md        # 🧠 Semantic Kernel Guide
├─ ssh_setup.md                       # 🔑 SSH Configuration
├─ unsloth_lora_finetuning.md         # 🎓 Model Fine-tuning
├─ vllm_integration.md                # ⚡ vLLM Integration
├─ workflow_integration.md            # 🔄 Workflow Engine Guide
└─ yarp_gateway_integration.md        # 🚪 YARP Gateway Setup

infra/ - Infrastructure

infra/
├─ cicd/                              # 🔄 CI/CD Pipeline Configs
│  └─ ...                             # GitHub Actions, Jenkins
│
├─ docker/                            # 🐳 Docker Configuration
│  ├─ Dockerfile.webapi               # Backend Dockerfile
│  ├─ Dockerfile.react                # Frontend Dockerfile
│  ├─ docker-compose.yml              # Compose orchestration
│  ├─ nginx.conf                      # Nginx configuration
│  └─ ...
│
├─ envsetup/                          # 🛠️ Environment Setup Scripts
│  ├─ install_dependencies.sh
│  ├─ setup_database.sh
│  └─ ...
│
├─ helm/                              # ⎈ Helm Charts
│  └─ agent-project/                  # Kubernetes deployment charts
│     ├─ Chart.yaml
│     ├─ values.yaml
│     └─ templates/
│
├─ kubernetes/                        # ☸️ Raw K8s Manifests
│  ├─ namespace.yaml
│  ├─ deployments.yaml
│  ├─ services.yaml
│  ├─ ingress.yaml
│  └─ ...
│
└─ git_ci.yml                         # 🔧 GitHub Actions Workflow

llm/ - Machine Learning Components

llm/
├─ deploy/                            # 🚀 Model Deployment
│  ├─ model_server.py                 # Model serving API
│  ├─ requirements.txt
│  └─ Dockerfile
│
└─ finetune/                          # 🎓 Model Fine-tuning
   ├─ train.py                        # Training scripts
   ├─ evaluate.py                     # Evaluation scripts
   ├─ dataset_loader.py               # Data loading utilities
   ├─ config.yaml                     # Training configuration
   └─ ...

test/ - Test Suites

test/
├─ Agent.Api.Tests/                   # 🧪 API Layer Tests
│  └─ ...                             # Controller & Endpoint tests
│
└─ Agent.Core.Tests/                  # 🧪 Core Business Logic Tests
   ├─ Unit/                           # Unit Tests
   │  ├─ Services/                    # Service layer tests
   │  ├─ Repositories/                # Data access tests
   │  └─ ...
   ├─ Integration/                    # Integration Tests
   │  ├─ ApiIntegrationTests.cs
   │  ├─ DatabaseIntegrationTests.cs
   │  └─ WorkflowIntegrationTests.cs
   └─ MockData/                       # Test Data Factories
      ├─ TestDataFactory.cs
      └─ MockServices.cs

🚀 Quick Start

Option 1️⃣: Docker Deployment (Recommended)

# Clone repository
git clone https://github.com/DrDrZ95/AgentProject.git
cd AgentProject

# Navigate to Docker directory
cd infra/docker

# Start all services
docker-compose up -d

# Check service status
docker-compose ps

# View live logs
docker-compose logs -f

# Stop services
docker-compose down

Service Access Points:

🌐 Frontend UI: http://localhost:3000
📡 Backend API: http://localhost:5000
📚 API Documentation: http://localhost:5000/swagger
📊 Prometheus: http://localhost:9090

Option 2️⃣: Local Development Deployment

# Clone repository
git clone https://github.com/DrDrZ95/AgentProject.git
cd AgentProject

# 1. Configure backend
cd apps/agent-api/Agent.Api
dotnet restore
dotnet build
dotnet run

# 2. In another terminal, configure frontend
cd apps/agent-ui
npm install
npm start

# 3. Setup database (requires PostgreSQL running)
# Update connection string in appsettings.json
# Then run migrations
dotnet ef database update

Option 3️⃣: Kubernetes Deployment

# Create namespace
kubectl create namespace agent-project

# Install using Helm
cd infra/helm
helm install agent-project ./agent-project-chart \
  -n agent-project \
  -f values.yaml

# Verify deployment
kubectl get pods -n agent-project
kubectl get svc -n agent-project

# View deployment logs
kubectl logs -n agent-project -l app=agent-project -f

📦 Deployment Guide

Docker Compose Configuration

# Service List
services:
  agent-api:           # ASP.NET Core Backend
  agent-ui:            # React Frontend
  postgres:            # Relational Database
  chromadb:            # Vector Database
  nginx:               # Reverse Proxy
  prometheus:          # Monitoring (Optional)
  mlflow:              # Experiment Tracking (Optional)

Environment Variables Configuration

# infra/docker/.env

# PostgreSQL Database
POSTGRES_PASSWORD=your_secure_password
DATABASE_CONNECTION_STRING=Host=postgres;Port=5432;Database=agent;...

# API Configuration
API_ENDPOINT=https://your-domain.com
API_PORT=5000

# LLM Service Configuration
OPENAI_API_KEY=sk-xxxxxxxxxxxxx
OPENAI_MODEL=gpt-4
DEEPSEEK_API_KEY=xxxxxxxxxxxxx
DEEPSEEK_MODEL=deepseek-chat
KIMI_API_KEY=xxxxxxxxxxxxx
KIMI_MODEL=moonshot-v1
LLAMA_API_ENDPOINT=http://localhost:8000
LLAMA_MODEL=llama-4-70b

# Authentication
JWT_SECRET_KEY=your-super-secret-key-min-32-chars
IDENTITY_SEED_ADMIN_PASSWORD=Admin@123456

# Vector Database
CHROMADB_HOST=chromadb
CHROMADB_PORT=8000

# Web Search
ENABLE_WEB_SEARCH=true
SEARXNG_ENDPOINT=http://searxng:8888

# Monitoring & Telemetry
ENABLE_PROMETHEUS=true
ENABLE_MLFLOW=true

Production Deployment Checklist

Configure HTTPS/TLS certificates
Setup database backups and replication
Configure external authentication (OIDC/LDAP)
Enable audit logging
Deploy monitoring and alerting system
Configure log aggregation
Test disaster recovery procedures
Establish CI/CD automation pipeline
Perform performance and load testing
Conduct security audit

🔧 Core Modules

Agent.Api - Application Entry Point

Responsibility: Application startup, dependency injection, middleware configuration
Key Files: Program.cs, GlobalUsings.cs
Extension Points: ServiceCollectionExtensions, MiddlewareExtensions

Agent.Application - Application Orchestration

Responsibility: CQRS pattern implementation, DTO mapping, business process orchestration
Key Features: MediatR command/query handling, AutoMapper, validation pipeline
Extension Points: CommandHandlers, QueryHandlers, Behaviors

Agent.Core - Core Business Logic

Identity & Authorization: Role-based, policy-based, claim-based authorization
Workflow & Task Management: Orchestration and execution of complex processes
System Monitoring: eBPF and security detection
Data Access: EF Core repositories
Real-Time Communication: SignalR integration
Gateway & Routing: YARP reverse proxy
Exception & Logging: Unified exception handling and structured logging
Identity Management: User, role, and permission management

Agent.McpGateway - AI Orchestration Engine

LLM Integration: Semantic Kernel wrapper, model routing
Knowledge Base & RAG: Document processing, vector database, similarity search
Workflow Orchestration: Complex task orchestration and execution with visual editor
Prompt Engineering: Template management, optimization, and tool call reliability
Sandbox Execution: Isolated command execution
Search & Integration: Web search, cache warmup, tool integration, file management
Model Fine-Tuning: Dataset preparation, model training, usage metering
Observability: Agent trace, telemetry and metrics collection

📚 Documentation

Document	Description	Link
`api_documentation.md`	Complete API reference with examples	View
`chromadb_integration.md`	Vector database setup and RAG configuration	View
`clickhouse_integration.md`	ClickHouse analytics database integration	View
`deepo_unsloth_cuda_setup.md`	Deepo and Unsloth CUDA environment setup	View
`docker_quickstart.md`	Quick start guide for Docker deployment	View
`dynamic_external_access.md`	Dynamic external access configuration	View
`ebpf_integration.md`	eBPF security module and system monitoring	View
`environment_setup.md`	Development environment configuration	View
`github_upload.md`	GitHub repository upload guide	View
`grafana_integration.md`	Grafana dashboard and visualization setup	View
`harbor_installation.md`	Harbor container registry installation	View
`helm_installation.md`	Helm charts for Kubernetes deployment	View
`identity_signalr_integration.md`	Authentication and real-time communication	View
`mcp_integration_guide.zh_CN.md`	Model Context Protocol integration guide	View
`mlflow_integration.md`	MLflow experiment tracking and model management	View
`openmanus_integration.md`	OpenManus integration guide	View
`prometheus_integration.md`	Prometheus metrics and monitoring	View
`prompt-engineering-best-practices.md`	Prompt engineering best practices guide	View
`rag_prompt_engineering.md`	RAG implementation and prompt optimization	View
`sandbox_terminal_integration.md`	Secure sandbox execution environment	View
`semantic_kernel_examples.md`	Semantic Kernel usage examples	View
`ssh_setup.md`	SSH configuration for remote access	View
`unsloth_lora_finetuning.md`	Model fine-tuning with Unsloth LoRA	View
`vllm_integration.md`	vLLM high-performance inference	View
`workflow_integration.md`	Workflow engine design and implementation	View
`yarp_gateway_integration.md`	YARP reverse proxy and gateway	View

👨‍💻 Development Guide

Build from Source

# Backend
cd apps/agent-api
dotnet restore
dotnet build -c Release
dotnet test

# Frontend
cd apps/agent-ui
npm install
npm run build
npm test

Development Workflow

Create feature branch: git checkout -b feature/your-feature
Write code: Follow coding standards
Write tests: Unit and integration tests
Commit changes: git commit -am 'Add feature'
Push code: git push origin feature/your-feature
Create PR: Detailed description of changes
Code review: Wait for maintainer review
Merge: Merge after approval

Coding Standards

C#: Follow Microsoft C# coding guidelines
TypeScript: Use ESLint and Prettier
Commits: [feat|fix|docs|style|refactor|test]: description

🤝 Contributing Guide

We welcome any form of contribution! Whether it's code improvements, documentation updates, bug fixes, or new feature suggestions, we appreciate your involvement.

Contribution Process

Fork the repository
Create a feature branch (git checkout -b feature/AmazingFeature)
Commit changes (git commit -m 'Add some AmazingFeature')
Push to branch (git push origin feature/AmazingFeature)
Open a Pull Request

Welcome Feedback & Suggestions

💡 Share Optimization Suggestions in PRs: If you have ideas for improving code, performance, or user experience, please share them in detail in your Pull Request
🐛 Report Bugs: If you find any issues, please report them via Issues with reproduction steps
✨ Feature Suggestions: For new features or improvements, feel free to discuss in Issues or Discussions
📝 Documentation Improvements: If documentation is unclear or incomplete, we welcome improvement suggestions

Contribution Requirements

✅ All tests must pass
✅ Code conforms to project style guidelines
✅ Commit messages are clear and concise
✅ PR includes detailed description of changes
✅ New features require documentation updates

Review Process

Our maintenance team will review Pull Requests regularly. You may receive feedback such as:

Code review comments
Requests for additional tests
Documentation update suggestions
Performance or security optimization recommendations

Please be patient with the review process as we aim to maintain code quality and long-term project maintainability.

📄 License

This project is licensed under the MIT License. See LICENSE file for details.

MIT License allows:

✅ Commercial use
✅ Code modification
✅ Distribution
✅ Private use

Conditions:

📌 Must include license copy
📌 Must state significant changes

🔗 Related Resources

Official Documentation

Related Projects

Reference Links

GitHub Repository: https://github.com/DrDrZ95/AgentProject

📞 Support & Feedback

Getting Help

Community Support

Review existing Issues and Discussions
Participate in GitHub Discussions
Contribute improvements and bug fixes

📊 Project Statistics

Programming Languages: C# (68.6%), TypeScript (27.1%), Python (2.6%), Shell (0.8%), HTML (0.6%), Go Template (0.2%), Other (0.1%)
Framework Versions: .NET 8.0, React 18+, ASP.NET Core 8.0
Lines of Code: 20,000+
Module Count: 25+
Documentation Pages: 60+
Test Coverage: 80%+
Commits: 215+
Stars: 21+
Forks: 3+

🎯 Roadmap

Phase 1 Completed ✅

✅ Core AI agent framework with .NET 8.0
✅ Workflow management system with visual editor
✅ RAG (Retrieval-Augmented Generation) implementation
✅ Docker deployment support with multi-container orchestration
✅ System architecture optimization with layered design
✅ Modularization refactor with clean architecture principles
✅ OpenAPI documentation with unified response models
✅ Comprehensive unit and integration test coverage

Phase 2 In Progress 🚀

✅ Agent Trace - Distributed tracing and observability for AI agents
✅ Dark Theme Support - UI theme switching capability
✅ Workflow Visualization Backend - Visual workflow editor backend
✅ Cache Warmup - Intelligent cache preloading
✅ Tool Call Reliability Enhancement - Improved tool execution stability
✅ OpenAPI Documentation Enhancement - Scalar integration and export capabilities
✅ Autofac DI Integration - Unified assembly scanning dependency injection
🔄 Advanced caching strategy optimization (Redis integration)
🔄 WebSearch enhancement and expansion (multi-provider support)
🔄 Model fine-tuning tool refinement with MLflow integration
🔄 Performance benchmark testing and optimization
🔄 API gateway enhancements with YARP
🔄 Real-time collaboration features

Phase 3 Planned 🔮

🔮 Multi-language support (Chinese, English, Japanese, Korean)
🔮 Additional LLM integrations (Claude, Gemini, local models)
🔮 Community plugin system with marketplace
🔮 Desktop client (Electron-based)
🔮 Mobile app support (React Native)
🔮 GraphQL API layer alongside REST
🔮 Advanced analytics dashboard
🔮 Enterprise SSO integration (SAML/OIDC)

Phase 4 Future Vision 🔭

🔭 AI-powered code generation assistant
🔭 Automated workflow optimization with self-learning capabilities
🔭 Multi-tenant SaaS architecture with tenant isolation
🔭 Advanced security compliance (SOC 2, GDPR, ISO 27001)
🔭 Cloud-native serverless deployment options (AWS Lambda, Azure Functions)
🔭 Edge computing support for low-latency scenarios
🔭 Federated learning integration for distributed model training
🔭 Natural language to workflow conversion
🔭 Autonomous agent swarms for complex task coordination
🔭 Quantum-resistant cryptography implementation

manus-project-expert

SKILL.md