AIECS
1.5.3

Getting Started

  • Installation
    • Requirements
    • Basic Installation
      • From PyPI (Recommended)
      • From Source
    • Optional Dependencies
      • Documentation
      • Development
    • Post-Installation Setup
      • Check Dependencies
      • Download NLP Data
      • Apply Patches
    • Configuration
    • Verification
    • Troubleshooting
      • Common Issues
  • Quick Start Guide
    • Prerequisites
    • Basic Usage
      • Starting the Server
      • Using the Client
    • Working with Tools
      • Document Processing
      • Web Scraping
      • Data Analysis
    • Using LLM Providers
      • OpenAI
      • Google Vertex AI
    • Task Execution with Celery
      • Starting Workers
      • Submitting Tasks
    • WebSocket Communication
    • Next Steps
  • Configuration
    • Environment Variables
      • LLM Provider Configuration
        • OpenAI
        • Google Vertex AI
        • xAI
      • Database Configuration
        • PostgreSQL
      • Redis Configuration
      • Celery Configuration
      • Google Cloud Storage
      • Server Configuration
    • Tool Configuration
      • Document Parser Tool
      • Document Creator Tool
      • Web Scraper Tool
    • Configuration File
      • Example .env File
    • Programmatic Configuration
    • Best Practices
    • See Also
  • Advanced Usage
    • Agent System
      • Creating Custom Agents
    • Tool Integration
      • Creating Custom Tools
    • Context Management
      • Using Context Engine
    • Task Orchestration
      • Complex Task Workflows
    • Error Handling
      • Robust Error Handling
    • Monitoring and Observability
      • Metrics Collection
      • Distributed Tracing
    • Performance Optimization
      • Caching Strategies
      • Connection Pooling
    • Best Practices
    • See Also
  • AIECS Usage Guide
    • 🔧 Three Usage Modes Explained
      • 1️⃣ Standalone Service Mode
        • 🚀 Start Service
        • 🔧 Start Complete Distributed Environment
        • 📡 Client Calls
        • 🌐 WebSocket Client
      • 2️⃣ Library Import Mode
        • 📦 Basic Library Usage
        • 🎯 Using Session Context Manager (Recommended)
        • 🔧 Custom Configuration
      • 3️⃣ FastAPI Integration Mode
        • 🏗️ Sub-Application Mounting
        • 🔗 Component-Level Integration
        • 🎛️ Selective Feature Integration
    • 🔄 Usage Mode Comparison
    • ⚙️ Environment Configuration
      • Minimum Configuration (Library Usage)
      • Complete Configuration (Standalone Service)
      • Docker Quick Start
    • 🎯 Selection Recommendations
      • Choose Standalone Service, when:
      • Choose Library Import, when:
      • Choose FastAPI Integration, when:
    • 🛠️ Development and Debugging
    • 🔍 Troubleshooting
      • Common Issues:
  • AIECS Project Migration Summary
    • Completed Tasks
      • 1. Project Renaming ✓
      • 2. Main.py Entry File ✓
      • 3. README Documentation ✓
      • 4. PyProject.toml Configuration ✓
      • 5. Scripts Dependency Patches ✓
      • 6. NLP Data Package Auto-Download ✓
    • Additional Completed Work
    • Project Structure
    • Publishing Preparation
    • Usage Instructions
    • Important Notes
    • Automation Features
      • NLP Data Package Management
      • Java/Tika Integration Management
    • Java Environment Configuration Guide
      • Installing Java Runtime Environment
        • Linux (Ubuntu/Debian)
        • Linux (CentOS/RHEL/Fedora)
        • macOS
        • Windows
      • Verifying Tika Functionality
    • Docker Configuration Guide
      • Basic Python Image (Without Java)
      • Complete Image with Java
      • Docker Compose Configuration
      • Multi-Stage Build (Recommended for Production)
      • Build and Run Commands
      • Environment Variable Configuration
      • Verify Docker Deployment
      • Image Size Comparison

Domain Agent

  • Agent Domain Documentation
    • 📚 Documentation Files
      • 1. AGENT_INTEGRATION.md - Complete Integration Guide 📋
      • 2. MIGRATION_GUIDE.md - Migration Instructions 🔄
      • 2a. MIGRATION_CHECKLIST.md - Migration Checklist ✅
      • 2b. UPGRADE_GUIDE.md - Upgrade Guide with Examples 📖
      • 2c. FAQ.md - Frequently Asked Questions ❓
      • 2d. BREAKING_CHANGES_ANALYSIS.md - Breaking Changes Analysis 🔍
      • 3. EXAMPLES.md - Code Examples 💻
      • 4. CONTEXTENGINE_INTEGRATION.md - ContextEngine Patterns 🔗
      • 5. SESSION_MANAGEMENT.md - Session Management 📊
      • 6. PERFORMANCE_MONITORING.md - Performance & Health 📈
      • 7. SERIALIZATION.md - Serialization Best Practices 💾
      • 8. COMPRESSION_GUIDE.md - Compression Strategies 🗜️
      • 9. PARALLEL_TOOL_EXECUTION.md - Parallel Execution ⚡
      • 10. TOOL_CACHING.md - Tool Result Caching 💾
      • 11. STREAMING.md - Streaming Responses 📡
      • 12. COLLABORATION.md - Multi-Agent Collaboration 🤝
      • 13. LEARNING.md - Agent Learning & Adaptation 🧠
      • 14. RESOURCE_MANAGEMENT.md - Resource Management ⚙️
      • 15. ERROR_RECOVERY.md - Error Recovery 🔄
      • 16. PERFORMANCE_OPTIMIZATION.md - Performance Optimization ⚡
      • 17. MULTI_AGENT_DESIGN.md - Multi-Agent System Design 🏗️
      • 18. TOOL_OBSERVATION.md - ToolObservation Pattern 📊
      • 19. MASTERCONTROLLER_MIGRATION.md - MasterController Migration 🔀
      • 20. OBSERVATION_REASONING.md - Observation-Based Reasoning 🔍
      • 21. API_REFERENCE.md - Complete API Reference 📚
    • 🚀 Quick Start
      • For New Users
      • For Existing Users
    • 📖 Related Documentation
    • 🎯 Key Features
    • 📝 Documentation Status
    • 🤝 Contributing
  • Agent Integration Guide
    • Table of Contents
    • Overview
    • Agent Types
      • BaseAIAgent
      • LLMAgent
      • ToolAgent
      • HybridAgent
    • Tool Integration
      • Tool Names (Simple)
      • Tool Instances (Advanced)
      • Stateful Tool Example
      • Tool with Dependencies Example
    • LLM Client Integration
      • Standard LLM Clients
      • Custom LLM Clients
      • LLM Client Wrappers
      • MasterController Integration
    • Memory and Session Management
      • Basic Memory
      • ContextEngine Integration
      • Session Lifecycle Management
      • Conversation Compression
    • Configuration Management
      • Static Configuration
      • Dynamic Configuration
      • Environment-Based Configuration
    • State Persistence
      • Checkpointers
      • LangGraph Integration
    • Performance Features
      • Tool Result Caching
      • Parallel Tool Execution
      • Streaming Responses
    • Collaboration Features
      • Multi-Agent Workflows
      • Task Delegation
    • Learning and Adaptation
      • Experience Recording
      • Approach Recommendation
    • Resource Management
      • Resource Limits
      • Throttling
    • Error Recovery
      • Recovery Strategies
      • Custom Recovery Logic
    • Observability
      • Performance Metrics
      • Health Status
      • Tool Observations
    • Best Practices
      • 1. Tool Selection
      • 2. LLM Client Selection
      • 3. Memory Management
      • 4. Configuration
      • 5. Performance
      • 6. Error Handling
      • 7. Resource Management
      • 8. Observability
    • Next Steps
  • Agent Domain API Reference
    • Table of Contents
    • BaseAIAgent
      • Lifecycle Methods
        • async initialize() -> None
        • async activate() -> None
        • async deactivate() -> None
        • async shutdown() -> None
      • State Management
        • state() -> AgentState
        • get_state() -> AgentState
      • Task Execution
        • async execute_task(task: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]
        • async process_message(message: str, sender_id: Optional[str] = None) -> Dict[str, Any]
      • Tool Execution
        • async execute_tool(tool_name: str, parameters: Dict[str, Any]) -> Any
        • async execute_tools_parallel(tool_calls: List[Dict[str, Any]], max_concurrency: int = 5) -> List[Dict[str, Any]]
        • async execute_tool_with_cache(tool_name: str, parameters: Dict[str, Any]) -> Any
        • invalidate_cache(tool_name: Optional[str] = None, pattern: Optional[str] = None) -> int
        • get_cache_stats() -> Dict[str, Any]
      • Streaming
        • async execute_task_streaming(task: Dict[str, Any], context: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]
        • async process_message_streaming(message: str, sender_id: Optional[str] = None) -> AsyncIterator[str]
      • Memory Management
        • async add_to_memory(key: str, value: Any, memory_type: MemoryType = MemoryType.SHORT_TERM) -> None
        • async retrieve_memory(key: str, default: Any = None) -> Any
        • async clear_memory(memory_type: Optional[MemoryType] = None) -> None
        • get_memory_summary() -> Dict[str, Any]
      • Goals Management
        • set_goal(goal_id: str, description: str, priority: GoalPriority = GoalPriority.MEDIUM, deadline: Optional[datetime] = None) -> AgentGoal
        • get_goals(status: Optional[GoalStatus] = None) -> List[AgentGoal]
        • get_goal(goal_id: str) -> Optional[AgentGoal]
        • update_goal_status(goal_id: str, status: GoalStatus, notes: Optional[str] = None) -> None
      • Configuration Management
        • get_config() -> AgentConfiguration
        • update_config(updates: Dict[str, Any]) -> None
      • Capabilities
        • declare_capability(capability_type: str, description: str, level: CapabilityLevel = CapabilityLevel.BASIC) -> None
        • has_capability(capability_type: str) -> bool
        • get_capabilities() -> List[AgentCapabilityDeclaration]
      • Metrics and Performance
        • get_metrics() -> AgentMetrics
        • update_metrics(execution_time: Optional[float] = None, success: Optional[bool] = None, tokens_used: Optional[int] = None, tool_calls: Optional[int] = None) -> None
        • track_operation_time(operation_name: str) -> OperationTimer
        • get_performance_metrics() -> Dict[str, Any]
        • get_health_status() -> Dict[str, Any]
        • get_comprehensive_status() -> Dict[str, Any]
        • reset_metrics() -> None
      • Serialization
        • to_dict() -> Dict[str, Any]
        • @classmethod from_dict(data: Dict[str, Any]) -> BaseAIAgent
      • Checkpointing
        • async save_checkpoint(session_id: Optional[str] = None) -> Optional[str]
        • async load_checkpoint(checkpoint_id: str) -> bool
      • Agent Collaboration
        • async delegate_task(task_description: str, target_agent_id: Optional[str] = None, required_capabilities: Optional[List[str]] = None, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]
        • async find_capable_agents(required_capabilities: List[str]) -> List[Any]
        • async request_peer_review(task: Dict[str, Any], result: Dict[str, Any], reviewer_id: Optional[str] = None) -> Dict[str, Any]
        • async collaborate_on_task(task: Dict[str, Any], strategy: str = "parallel", required_capabilities: Optional[List[str]] = None, agent_weights: Optional[Dict[str, float]] = None) -> Dict[str, Any]
      • Learning and Adaptation
        • async record_experience(task: Dict[str, Any], result: Dict[str, Any], approach: str, tools_used: Optional[List[str]] = None) -> None
        • async get_recommended_approach(task: Dict[str, Any]) -> Optional[Dict[str, Any]]
        • async get_learning_insights() -> Dict[str, Any]
        • async adapt_strategy(task: Dict[str, Any]) -> Dict[str, Any]
      • Resource Management
        • async check_resource_availability() -> Dict[str, Any]
        • async wait_for_resources(timeout: Optional[float] = None) -> bool
        • async get_resource_usage() -> Dict[str, Any]
      • Error Recovery
        • async execute_with_recovery(task: Dict[str, Any], context: Dict[str, Any], strategies: Optional[List[str]] = None) -> Dict[str, Any]
      • Context Management
        • async get_relevant_context(query: str, max_items: int = 10, min_score: float = 0.5) -> List[Dict[str, Any]]
        • async score_context_relevance(context_items: List[Dict[str, Any]], query: str) -> List[float]
        • async prune_context(context_items: List[Dict[str, Any]], max_tokens: int, query: Optional[str] = None, preserve_types: Optional[List[str]] = None) -> List[Dict[str, Any]]
      • Utility Methods
        • is_available() -> bool
        • is_busy() -> bool
    • Concrete Agent Types
      • LLMAgent
        • Methods
        • async execute_task(task: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]
        • async process_message(message: str, sender_id: Optional[str] = None) -> Dict[str, Any]
        • async execute_task_streaming(task: Dict[str, Any], context: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]
      • ToolAgent
        • Methods
        • async execute_task(task: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]
      • HybridAgent
        • Methods
        • async execute_task(task: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]
        • async process_message(message: str, sender_id: Optional[str] = None) -> Dict[str, Any]
        • async execute_task_streaming(task: Dict[str, Any], context: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]
        • async _execute_tool_with_observation(tool_name: str, operation: Optional[str], parameters: Dict[str, Any]) -> ToolObservation
        • get_available_tools() -> List[str]
    • ConversationMemory and Session
      • ConversationMemory
        • Methods
        • async add_message(role: str, content: str, session_id: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> None
        • async get_messages(session_id: Optional[str] = None, limit: Optional[int] = None) -> List[LLMMessage]
        • async clear(session_id: Optional[str] = None) -> None
        • async get_session(session_id: str) -> Optional[Session]
        • async create_session(session_id: Optional[str] = None, user_id: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> Session
        • async end_session(session_id: str, status: str = "completed") -> None
        • async list_sessions(active_only: bool = False) -> List[Session]
      • Session
        • Methods
        • add_message(role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None
        • track_request(processing_time: float, is_error: bool = False) -> None
        • get_metrics() -> Dict[str, Any]
        • is_active() -> bool
        • end(status: str = "completed") -> None
        • is_expired(max_idle_seconds: int = 1800) -> bool
    • ContextEngine
      • Initialization
        • async initialize() -> None
      • Session Management
        • async create_session(session_id: Optional[str] = None, user_id: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> str
        • async get_session(session_id: str) -> Optional[SessionMetrics]
        • async end_session(session_id: str, status: str = "completed") -> None
      • Conversation History
        • async add_message(session_id: str, role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None
        • async get_messages(session_id: str, limit: Optional[int] = None, offset: int = 0) -> List[ConversationMessage]
        • async clear_messages(session_id: str) -> None
      • Compression Methods
        • async compress_conversation(session_id: str, strategy: Optional[str] = None, target_length: Optional[int] = None, custom_prompt: Optional[str] = None) -> Dict[str, Any]
        • async summarize_conversation(session_id: str, max_messages: Optional[int] = None, custom_prompt: Optional[str] = None) -> str
        • async truncate_conversation(session_id: str, keep_last: int) -> int
        • async semantic_compress_conversation(session_id: str, query: Optional[str] = None, max_messages: Optional[int] = None) -> Dict[str, Any]
      • Context Storage
        • async store_context(session_id: str, key: str, value: Any, metadata: Optional[Dict[str, Any]] = None) -> None
        • async get_context(session_id: str, key: str, default: Any = None) -> Any
        • async list_context_keys(session_id: str) -> List[str]
      • Cleanup
        • async cleanup_expired_sessions(max_idle_seconds: int = 1800) -> int
    • Models and Configuration
      • CompressionConfig
        • Fields
      • CacheConfig
        • Fields
        • Methods
      • ResourceLimits
        • Fields
      • Experience
        • Fields
      • RecoveryStrategy
        • Enum Values
        • Usage Pattern
    • Protocols
      • LLMClientProtocol
        • Required Attributes
        • Required Methods
        • Example Implementation
      • ConfigManagerProtocol
        • Required Methods
        • Example Implementation
      • CheckpointerProtocol
        • Required Methods
        • Example Implementation
      • AgentCollaborationProtocol
        • Required Attributes
        • Required Methods
        • Example Implementation
    • ToolObservation
      • Fields
        • Field Descriptions
      • Methods
        • Method Descriptions
    • Enhanced Methods
      • _execute_tool_with_observation()
        • Description
        • Parameters
        • Returns
        • Example
        • Notes
    • Performance Enhancement APIs
      • Caching APIs
        • execute_tool_with_cache(tool_name: str, parameters: Dict[str, Any]) -> Any
        • invalidate_cache(tool_name: Optional[str] = None, pattern: Optional[str] = None) -> int
        • get_cache_stats() -> Dict[str, Any]
      • Parallel Execution APIs
        • execute_tools_parallel(tool_calls: List[Dict[str, Any]], max_concurrency: int = 5) -> List[Dict[str, Any]]
        • analyze_tool_dependencies(tool_calls: List[Dict[str, Any]]) -> Dict[str, List[str]]
        • execute_tools_with_dependencies(tool_calls: List[Dict[str, Any]], max_concurrency: int = 5) -> List[Dict[str, Any]]
      • Streaming APIs
        • execute_task_streaming(task: Dict[str, Any], context: Dict[str, Any]) -> AsyncIterator[Dict[str, Any]]
        • process_message_streaming(message: str, sender_id: Optional[str] = None) -> AsyncIterator[str]
    • Reliability Enhancement APIs
      • Error Recovery APIs
        • execute_with_recovery(task: Dict[str, Any], context: Dict[str, Any], strategies: Optional[List[str]] = None) -> Dict[str, Any]
      • Resource Management APIs
        • check_resource_availability() -> Dict[str, Any]
        • wait_for_resources(timeout: Optional[float] = None) -> bool
        • get_resource_usage() -> Dict[str, Any]
      • Checkpointing APIs
        • save_checkpoint(session_id: Optional[str] = None) -> Optional[str]
        • load_checkpoint(checkpoint_id: str) -> bool
    • Observability Enhancement APIs
      • Metrics APIs
        • get_metrics() -> AgentMetrics
        • update_metrics(execution_time: Optional[float] = None, success: Optional[bool] = None, tokens_used: Optional[int] = None, tool_calls: Optional[int] = None) -> None
        • get_performance_metrics() -> Dict[str, Any]
        • reset_metrics() -> None
      • Health Status APIs
        • get_health_status() -> Dict[str, Any]
        • get_comprehensive_status() -> Dict[str, Any]
      • Operation Tracking APIs
        • track_operation_time(operation_name: str) -> OperationTimer
      • Session Metrics APIs
        • update_session_metrics(session_id: str, processing_time: float, is_error: bool = False) -> None
  • Example Implementations: Common Patterns
    • Table of Contents
    • Stateful Tools
      • Example 1: Database Query Tool
      • Example 2: Context Engine Tool
      • Example 3: Service Integration Tool
    • Custom LLM Clients
      • Example 1: Retry Wrapper
      • Example 2: Caching Wrapper
      • Example 3: Custom LLM Provider
    • Config Managers
      • Example 1: Database Config Manager
      • Example 2: Redis Config Manager
    • Checkpointers
      • Example 1: File-Based Checkpointer
      • Example 2: Redis Checkpointer
    • Complete Integration Examples
      • Example: MasterController Integration
      • Example: Production Agent Setup
    • Summary
  • FAQ: Enhanced Hybrid Agent Flexibility
    • General Questions
      • Q: Do I need to migrate my existing code?
      • Q: Will my existing agents break?
      • Q: What’s the performance impact?
      • Q: Are there any breaking changes?
    • Tool Instances
      • Q: When should I use tool instances instead of tool names?
      • Q: Can I mix tool names and tool instances?
      • Q: Do tool instances preserve state?
    • Custom LLM Clients
      • Q: What’s the difference between BaseLLMClient and LLMClientProtocol?
      • Q: How do I make my custom LLM client work with agents?
      • Q: Can I use MasterController’s LLMIntegrationManager?
    • ContextEngine Integration
      • Q: Do I need ContextEngine for agents to work?
      • Q: How do I set up ContextEngine?
      • Q: Does conversation history persist across agent restarts?
      • Q: Can multiple agents share the same ContextEngine?
    • Session Management
      • Q: What’s the difference between agent_id and session_id?
      • Q: How do I create a session?
      • Q: How do I track session metrics?
      • Q: How do I clean up old sessions?
    • Performance Features
      • Q: How much faster is parallel tool execution?
      • Q: How much can tool caching reduce costs?
      • Q: How do I configure caching?
    • Resource Management
      • Q: What are resource limits?
      • Q: How do I set resource limits?
      • Q: What happens when limits are exceeded?
    • Learning and Adaptation
      • Q: What is agent learning?
      • Q: How do I enable learning?
      • Q: How do I record experiences?
      • Q: How do I get recommendations?
    • Collaboration
      • Q: What is agent collaboration?
      • Q: How do I enable collaboration?
      • Q: How do I delegate tasks?
    • Health Monitoring
      • Q: How do I check agent health?
      • Q: What affects health score?
      • Q: How do I get comprehensive status?
    • Troubleshooting
      • Q: My tool instances aren’t preserving state
      • Q: My custom LLM client isn’t working
      • Q: ContextEngine isn’t persisting data
      • Q: Performance is slower than expected
    • Migration Questions
      • Q: How do I migrate from tool names to tool instances?
      • Q: How do I migrate from BaseLLMClient to custom client?
      • Q: Can I migrate gradually?
    • Additional Resources
    • Still Have Questions?
  • Multi-Agent Collaboration Patterns
    • Table of Contents
    • Overview
      • When to Use Collaboration
    • Enabling Collaboration
      • Pattern 1: Basic Collaboration Setup
      • Pattern 2: Dynamic Registry
    • Task Delegation
      • Pattern 1: Delegate to Specific Agent
      • Pattern 2: Delegate by Capability
      • Pattern 3: Delegate with Context
    • Peer Review
      • Pattern 1: Request Peer Review
      • Pattern 2: Automatic Reviewer Selection
      • Pattern 3: Multiple Reviews
    • Consensus-Based Decisions
      • Pattern 1: Consensus on Task
      • Pattern 2: Parallel Execution with Consensus
      • Pattern 3: Weighted Consensus
    • Capability-Based Discovery
      • Pattern 1: Find Capable Agents
      • Pattern 2: Multiple Capabilities
      • Pattern 3: Capability Matching
    • Best Practices
      • 1. Use Specialized Agents
      • 2. Enable Collaboration Only When Needed
      • 3. Monitor Collaboration Performance
      • 4. Handle Delegation Errors
      • 5. Use Peer Review for Quality
    • Summary
  • ContextEngine Compression Strategies
    • Table of Contents
    • Overview
      • Compression Strategies
    • Compression Strategies
      • Strategy 1: Truncate
      • Strategy 2: Summarize
      • Strategy 3: Semantic
      • Strategy 4: Hybrid
    • Configuration Options
      • Basic Configuration
      • Advanced Configuration
    • Use Cases
      • Use Case 1: Long Conversations
      • Use Case 2: Cost Optimization
      • Use Case 3: Quality Preservation
      • Use Case 4: Maximum Compression
    • Custom Compression Prompts
      • Pattern 1: Custom Summarization Prompt
      • Pattern 2: Domain-Specific Prompt
      • Pattern 3: Multi-Language Prompt
    • Auto-Compression
      • Pattern 1: Message Count Trigger
      • Pattern 2: Token Count Trigger
      • Pattern 3: Time-Based Compression
    • Best Practices
      • 1. Choose Appropriate Strategy
      • 2. Set Appropriate Thresholds
      • 3. Always Keep Recent Messages
      • 4. Use Custom Prompts
      • 5. Monitor Compression Performance
      • 6. Test Compression Quality
    • Summary
  • ContextEngine Integration Patterns
    • Table of Contents
    • Overview
      • Key Benefits
    • Basic Integration
      • Pattern 1: Simple Agent Integration
      • Pattern 2: ContextEngine with Redis
      • Pattern 3: In-Memory Fallback
    • Session Management Patterns
      • Pattern 1: Session Lifecycle
      • Pattern 2: Session Tracking with Agents
      • Pattern 3: Session Cleanup
      • Pattern 4: Session Metrics Aggregation
    • Conversation History Patterns
      • Pattern 1: Persistent Conversation History
      • Pattern 2: Conversation History Retrieval
      • Pattern 3: Conversation History with Compression
    • Context Storage Patterns
      • Pattern 1: Store and Retrieve Context
      • Pattern 2: Context Updates
      • Pattern 3: Context Listing
    • Multi-Agent Patterns
      • Pattern 1: Shared ContextEngine
      • Pattern 2: Agent-Specific Context
    • Production Patterns
      • Pattern 1: Redis Configuration
      • Pattern 2: Compression Configuration
      • Pattern 3: Error Handling
      • Pattern 4: Monitoring
    • Best Practices
      • 1. Always Initialize ContextEngine
      • 2. Use Consistent Session IDs
      • 3. Clean Up Inactive Sessions
      • 4. Configure Compression
      • 5. Handle Errors Gracefully
      • 6. Monitor Performance
      • 7. Use Redis for Production
    • Summary
  • Error Recovery Strategies
    • Table of Contents
    • Overview
      • Recovery Strategies
    • Recovery Strategies
      • Strategy 1: RETRY
      • Strategy 2: SIMPLIFY
      • Strategy 3: FALLBACK
      • Strategy 4: DELEGATE
      • Strategy 5: ABORT
    • Basic Recovery Configuration
      • Pattern 1: Single Strategy
      • Pattern 2: Multiple Strategies
      • Pattern 3: Default Strategies
    • Strategy Chains
      • Pattern 1: Full Recovery Chain
      • Pattern 2: Conservative Chain
      • Pattern 3: Quick Fail Chain
    • Custom Recovery Logic
      • Pattern 1: Custom Retry Logic
      • Pattern 2: Custom Simplification
      • Pattern 3: Custom Fallback
    • Error Classification
      • Pattern 1: Error-Based Strategy Selection
      • Pattern 2: Automatic Error Classification
    • Best Practices
      • 1. Use Appropriate Strategy Order
      • 2. Configure Based on Error Types
      • 3. Limit Recovery Attempts
      • 4. Monitor Recovery Success
      • 5. Handle Recovery Failures
    • Summary
  • Agent Learning and Adaptation
    • Table of Contents
    • Overview
      • When to Use Learning
    • Enabling Learning
      • Pattern 1: Basic Learning Setup
      • Pattern 2: Learning with Experience Limit
    • Recording Experiences
      • Pattern 1: Automatic Recording
      • Pattern 2: Manual Recording
      • Pattern 3: Record After Execution
      • Pattern 4: Record Failed Experiences
    • Getting Recommendations
      • Pattern 1: Get Recommended Approach
      • Pattern 2: Compare Approaches
      • Pattern 3: Task-Specific Recommendations
    • Experience Analysis
      • Pattern 1: Get All Experiences
      • Pattern 2: Filter Experiences
      • Pattern 3: Analyze Performance
    • Adaptation Strategies
      • Pattern 1: Adaptive Approach Selection
      • Pattern 2: Learning from Failures
      • Pattern 3: Performance-Based Adaptation
    • Best Practices
      • 1. Enable Learning for Repetitive Tasks
      • 2. Record Comprehensive Experiences
      • 3. Use Recommendations Wisely
      • 4. Analyze Experience Patterns
      • 5. Learn from Failures
    • Summary
  • Observation-Based Reasoning Loops
    • Table of Contents
    • Overview
      • When to Use Observation-Based Reasoning
    • Basic ReAct Loop
      • Pattern 1: Simple ReAct Loop
      • Pattern 2: ReAct Loop with History
    • Advanced Reasoning Loops
      • Pattern 1: Parallel Tool Execution
      • Pattern 2: Conditional Tool Execution
    • Multi-Tool Reasoning
      • Pattern 1: Sequential Tool Chain
      • Pattern 2: Dependent Tool Chain
    • Error Recovery in Loops
      • Pattern 1: Retry on Failure
      • Pattern 2: Fallback Tools
    • Observation Analysis
      • Pattern 1: Performance Analysis
      • Pattern 2: Error Analysis
    • Best Practices
      • 1. Always Use Observations
      • 2. Check Success Before Using
      • 3. Format for LLM Context
      • 4. Track Performance
      • 5. Analyze Patterns
    • Summary
  • Parallel Tool Execution Patterns
    • Table of Contents
    • Overview
      • When to Use Parallel Execution
      • When NOT to Use Parallel Execution
    • Basic Parallel Execution
      • Pattern 1: Simple Parallel Execution
      • Pattern 2: With Concurrency Limit
      • Pattern 3: Automatic Detection
    • Concurrency Control
      • Pattern 1: Default Concurrency
      • Pattern 2: Custom Concurrency
      • Pattern 3: High Concurrency
      • Pattern 4: Resource-Based Concurrency
    • Dependency Handling
      • Pattern 1: Independent Tools
      • Pattern 2: Dependent Tools
      • Pattern 3: Mixed Dependencies
    • Error Handling
      • Pattern 1: Individual Error Handling
      • Pattern 2: Partial Success
      • Pattern 3: Retry Failed Tools
    • Performance Optimization
      • Pattern 1: Batch Execution
      • Pattern 2: Priority-Based Execution
      • Pattern 3: Timeout Handling
    • Best Practices
      • 1. Use Parallel Execution for Independent Tools
      • 2. Set Appropriate Concurrency Limits
      • 3. Handle Errors Gracefully
      • 4. Monitor Performance
      • 5. Use for I/O-Bound Operations
    • Summary
  • Performance Monitoring and Health Status
    • Table of Contents
    • Overview
      • Key Metrics
    • Performance Metrics
      • Pattern 1: Basic Metrics Retrieval
      • Pattern 2: Detailed Performance Metrics
      • Pattern 3: Operation-Level Tracking
      • Pattern 4: Metrics Export
    • Health Status
      • Pattern 1: Basic Health Check
      • Pattern 2: Health Status Monitoring
      • Pattern 3: Health-Based Actions
      • Pattern 4: Health Score Calculation
    • Operation-Level Tracking
      • Pattern 1: Track Specific Operations
      • Pattern 2: Percentile Tracking
    • Monitoring Patterns
      • Pattern 1: Periodic Metrics Collection
      • Pattern 2: Metrics Aggregation
      • Pattern 3: Performance Dashboards
    • Alerting Patterns
      • Pattern 1: Health-Based Alerts
      • Pattern 2: Performance-Based Alerts
      • Pattern 3: Threshold-Based Alerts
    • Best Practices
      • 1. Monitor Regularly
      • 2. Track Key Metrics
      • 3. Set Appropriate Thresholds
      • 4. Alert on Critical Issues
      • 5. Aggregate Metrics
    • Summary
  • Performance Optimization Guide
    • Table of Contents
    • Overview
    • Caching Strategies
      • Pattern 1: Aggressive Caching
      • Pattern 2: Selective Caching
      • Pattern 3: Cache Invalidation
    • Parallel Execution
      • Pattern 1: Maximize Parallelism
      • Pattern 2: Batch Processing
    • Streaming Optimization
      • Pattern 1: Progressive Display
      • Pattern 2: Buffer Optimization
    • Resource Optimization
      • Pattern 1: Optimal Rate Limits
      • Pattern 2: Concurrent Task Optimization
    • Memory Optimization
      • Pattern 1: Conversation Compression
      • Pattern 2: Cache Size Limits
    • Monitoring and Profiling
      • Pattern 1: Performance Profiling
      • Pattern 2: Metrics Analysis
      • Pattern 3: Cache Performance
    • Best Practices
      • 1. Combine Optimization Techniques
      • 2. Monitor and Adjust
      • 3. Profile Before Optimizing
    • Summary
  • Resource Management Configuration
    • Table of Contents
    • Overview
      • When to Use Resource Management
    • Basic Configuration
      • Pattern 1: Basic Rate Limiting
      • Pattern 2: Production Configuration
      • Pattern 3: Monitoring Mode
    • Rate Limiting
      • Pattern 1: Token Rate Limiting
      • Pattern 2: Token Bucket with Burst
      • Pattern 3: Tool Call Rate Limiting
    • Concurrent Task Limits
      • Pattern 1: Basic Concurrent Limits
      • Pattern 2: Check Resource Availability
      • Pattern 3: Wait for Resources
    • Memory Limits
      • Pattern 1: Memory Constraints
      • Pattern 2: Memory Monitoring
    • Timeout Configuration
      • Pattern 1: Task Timeout
      • Pattern 2: Resource Wait Timeout
    • Enforcement Modes
      • Pattern 1: Enforce Limits
      • Pattern 2: Wait Mode
      • Pattern 3: Monitor Only
    • Resource Monitoring
      • Pattern 1: Check Resource Status
      • Pattern 2: Monitor Resource Usage
      • Pattern 3: Resource Alerts
    • Best Practices
      • 1. Set Appropriate Limits
      • 2. Use Token Bucket for Burst
      • 3. Monitor Before Enforcing
      • 4. Handle Resource Unavailability
      • 5. Set Appropriate Timeouts
    • Summary
  • Serialization Best Practices
    • Table of Contents
    • Overview
      • Serialization Features
    • Basic Serialization
      • Pattern 1: Serialize Agent State
      • Pattern 2: Deserialize Agent State
      • Pattern 3: State Transfer
    • State Persistence
      • Pattern 1: Save State to File
      • Pattern 2: Save State to Database
      • Pattern 3: Periodic State Backup
    • Handling Non-Serializable Objects
      • Pattern 1: Automatic Sanitization
      • Pattern 2: Custom Serialization
      • Pattern 3: Exclude Non-Serializable Objects
    • Checkpointing
      • Pattern 1: Basic Checkpointing
      • Pattern 2: Checkpoint with Custom Checkpointer
      • Pattern 3: LangGraph Integration
    • Best Practices
      • 1. Serialize Regularly
      • 2. Handle Serialization Errors
      • 3. Exclude Large Objects
      • 4. Validate Deserialized State
      • 5. Use Checkpoints for Recovery
      • 6. Backup State Regularly
      • 7. Compress Large States
    • Summary
  • Session Management Best Practices
    • Table of Contents
    • Overview
      • Session States
    • Session Lifecycle
      • Pattern 1: Basic Lifecycle
      • Pattern 2: Explicit Session Creation
      • Pattern 3: Session Status Management
    • Session Identification
      • Pattern 1: User-Based Sessions
      • Pattern 2: Device-Based Sessions
      • Pattern 3: Application-Based Sessions
      • Pattern 4: Temporary Sessions
    • Metrics Tracking
      • Pattern 1: Request Tracking
      • Pattern 2: Manual Metrics Update
      • Pattern 3: Metrics Aggregation
      • Pattern 4: Performance Monitoring
    • Session Cleanup
      • Pattern 1: Automatic Cleanup
      • Pattern 2: Scheduled Cleanup
      • Pattern 3: Custom Cleanup Logic
      • Pattern 4: Cleanup by Age
    • Error Handling
      • Pattern 1: Error Tracking
      • Pattern 2: Error Recovery
      • Pattern 3: Session Health Monitoring
    • Production Patterns
      • Pattern 1: Session Limits
      • Pattern 2: Session Timeout
      • Pattern 3: Session Pooling
    • Best Practices
      • 1. Use Consistent Session IDs
      • 2. End Sessions Explicitly
      • 3. Track Metrics
      • 4. Clean Up Inactive Sessions
      • 5. Monitor Session Health
      • 6. Handle Errors Gracefully
      • 7. Use Appropriate Timeouts
    • Summary
  • Streaming Response Usage
    • Table of Contents
    • Overview
      • When to Use Streaming
      • When NOT to Use Streaming
    • Basic Streaming
      • Pattern 1: Stream Task Execution
      • Pattern 2: Stream Message Processing
      • Pattern 3: Collect Streamed Results
    • Streaming Task Execution
      • Pattern 1: Basic Task Streaming
      • Pattern 2: ReAct Loop Streaming
      • Pattern 3: Lifecycle Tracking
    • Streaming Message Processing
      • Pattern 1: Conversational Streaming
      • Pattern 2: Multi-Turn Streaming
      • Pattern 3: Streaming with Context
    • Event Types
      • Token Events
      • Tool Call Events
      • Tool Result Events
      • Status Events
      • Lifecycle Events
      • ReAct Events (HybridAgent)
      • Tool Streaming Events (ToolAgent / HybridAgent)
      • Result Events
      • DAWP Boundary Events (HybridAgent + DawpPlugin)
      • Error Events
    • Error Handling
      • Pattern 1: Handle Streaming Errors
      • Pattern 2: Continue on Errors
      • Pattern 3: Retry on Errors
    • Best Practices
      • 1. Use Streaming for Long Operations
      • 2. Provide User Feedback
      • 3. Handle Partial Results
      • 4. Monitor Streaming Performance
      • 5. Buffer for Smooth Display
    • Summary
  • Tool Result Caching Best Practices
    • Table of Contents
    • Overview
      • When to Use Caching
      • When NOT to Use Caching
    • Basic Caching
      • Pattern 1: Enable Caching
      • Pattern 2: Disable Caching
      • Pattern 3: Automatic Caching
    • Cache Configuration
      • Pattern 1: Basic Configuration
      • Pattern 2: Aggressive Caching
      • Pattern 3: Conservative Caching
    • Per-Tool TTL Configuration
      • Pattern 1: Tool-Specific TTL
      • Pattern 2: Disable Caching for Specific Tools
      • Pattern 3: Long-Term Caching
    • Cache Management
      • Pattern 1: Cache Statistics
      • Pattern 2: Cache Cleanup
      • Pattern 3: Cache Size Monitoring
    • Cache Invalidation
      • Pattern 1: Invalidate Specific Tool
      • Pattern 2: Invalidate by Pattern
      • Pattern 3: Clear All Cache
      • Pattern 4: Time-Based Invalidation
    • Performance Monitoring
      • Pattern 1: Cache Hit Rate Monitoring
      • Pattern 2: Cost Savings Calculation
      • Pattern 3: Performance Impact
    • Best Practices
      • 1. Configure Appropriate TTL
      • 2. Monitor Cache Performance
      • 3. Set Appropriate Cache Size
      • 4. Invalidate Stale Data
      • 5. Use for Expensive Operations
      • 6. Handle Cache Errors Gracefully
    • Summary
  • ToolObservation Pattern Usage
    • Table of Contents
    • Overview
      • When to Use ToolObservation
    • Basic Usage
      • Pattern 1: Execute Tool with Observation
      • Pattern 2: Create Observation Manually
      • Pattern 3: Multiple Observations
    • Observation Formatting
      • Pattern 1: Text Formatting
      • Pattern 2: Multiple Observations Text
      • Pattern 3: Filtered Observations
    • Observation-Based Reasoning
      • Pattern 1: ReAct Loop with Observations
      • Pattern 2: Observation History
    • Error Handling
      • Pattern 1: Handle Failed Observations
      • Pattern 2: Error Observation Formatting
    • Serialization
      • Pattern 1: Dictionary Serialization
      • Pattern 2: Store Observations
      • Pattern 3: Load Observations
    • Best Practices
      • 1. Always Use Observations for Reasoning
      • 2. Check Success Before Using Results
      • 3. Format Observations for LLM
      • 4. Track Execution Time
      • 5. Store Observations for Analysis
    • Summary

Tools and Configuration

  • Document Parser Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. User Agent
      • 2. Max File Size
      • 3. Temp Directory
      • 4. Default Encoding
      • 5. Timeout
      • 6. Max Pages
      • 7. Enable Cloud Storage
      • 8. GCS Bucket Name
      • 9. GCS Project ID
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Cloud Storage Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Boolean Values
      • Optional Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Document Types
      • Office Documents
      • Text Documents
      • Data Documents
      • Media Documents
      • Unknown Documents
    • Parsing Strategies
      • Text Only
      • Structured
      • Full Content
      • Metadata Only
    • Output Formats
      • Text
      • JSON
      • Markdown
      • HTML
    • Cloud Storage
      • Google Cloud Storage Integration
      • GCS Configuration
      • Cloud Storage Benefits
    • Operations Supported
      • Document Detection
      • Document Download
      • Document Parsing
      • Content Processing
      • Output Generation
      • Cloud Storage Operations
      • Batch Operations
    • Troubleshooting
      • Issue: Directory not accessible
      • Issue: File too large
      • Issue: Download timeout
      • Issue: Parsing fails
      • Issue: Cloud storage not working
      • Issue: Encoding errors
      • Issue: Memory errors with large documents
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Document Writer Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Temp Directory
      • 2. Backup Directory
      • 3. Output Directory
      • 4. Max File Size
      • 5. Max Backup Versions
      • 6. Default Encoding
      • 7. Enable Backup
      • 8. Enable Versioning
      • 9. Enable Content Validation
      • 10. Enable Security Scan
      • 11. Atomic Write
      • 12. Validation Level
      • 13. Timeout Seconds
      • 14. Auto Backup
      • 15. Atomic Writes
      • 16. Default Format
      • 17. Version Control
      • 18. Security Scan
      • 19. Enable Cloud Storage
      • 20. GCS Bucket Name
      • 21. GCS Project ID
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Enterprise Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Boolean Values
      • Optional Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Document Formats
      • Text Formats
      • Document Formats
      • Binary Formats
    • Write Modes
      • Basic Modes
      • Advanced Modes
    • Edit Operations
      • Text Formatting
      • Text Operations
      • Advanced Operations
    • Encoding Types
      • Standard Encodings
      • Special Encodings
    • Validation Levels
      • Validation Types
    • Cloud Storage
      • Google Cloud Storage Integration
      • GCS Configuration
      • Cloud Storage Benefits
    • Operations Supported
      • Basic Writing
      • Advanced Writing
      • Document Operations
      • Edit Operations
      • Backup and Versioning
      • Validation and Security
      • Cloud Operations
      • Batch Operations
    • Troubleshooting
      • Issue: Directory not accessible
      • Issue: File too large
      • Issue: Backup creation fails
      • Issue: Validation fails
      • Issue: Security scan fails
      • Issue: Cloud storage not working
      • Issue: Atomic write fails
      • Issue: Timeout errors
    • Best Practices
      • Performance Optimization
      • Data Protection
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Tool Configuration Best Practices
    • Use BaseSettings Instead of BaseModel
      • Problem Background
      • Key Differences
      • Why It Matters
    • Configuration Priority
    • Usage Examples
      • Method 1: Using Environment Variables (Recommended)
      • Method 2: Explicitly Passing Configuration
      • Method 3: Mixed Usage
    • Dependencies
    • Verify Configuration
    • Common Questions
      • Q: Why don’t environment variables work after using get_tool()?
      • Q: Variables in .env file are not being read?
      • Q: How to check if a tool uses BaseSettings?
    • Fixed Tools
    • Related Documentation
  • AI Document Writer Orchestrator Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Default AI Provider
      • 2. Max Content Length
      • 3. Max Concurrent Writes
      • 4. Default Temperature
      • 5. Max Tokens
      • 6. Timeout
      • 7. Enable Draft Mode
      • 8. Enable Content Review
      • 9. Auto Backup on AI Write
      • 10. Temp Directory
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Performance Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Float Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Content Generation Modes
      • Basic Modes
      • Advanced Modes
    • AI Edit Operations
      • Smart Operations
    • Write Strategies
      • Writing Approaches
    • AI Providers
      • Supported Providers
      • Provider Configuration
    • Operations Supported
      • Basic Writing
      • Batch Operations
      • AI Edit Operations
      • Template Operations
      • Review Operations
      • Complex Operations
      • Utility Operations
    • Troubleshooting
      • Issue: AI Provider not available
      • Issue: Content generation fails
      • Issue: Write orchestration fails
      • Issue: Timeout errors
      • Issue: Backup failures
      • Issue: Review failures
      • Issue: Draft mode issues
      • Issue: Memory issues
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • AI Document Orchestrator Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Default AI Provider
      • 2. Max Chunk Size
      • 3. Max Concurrent Requests
      • 4. Default Temperature
      • 5. Max Tokens
      • 6. Timeout
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Performance Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Float Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Processing Modes
      • Basic Modes
      • Advanced Modes
    • AI Providers
      • Supported Providers
      • Provider Configuration
    • Operations Supported
      • Basic Processing
      • Async Processing
      • Custom Processing
      • Document Integration
      • AI Integration
    • Troubleshooting
      • Issue: AI Provider not available
      • Issue: Document parsing fails
      • Issue: Timeout errors
      • Issue: Memory issues
      • Issue: Concurrency limits
      • Issue: Token limit exceeded
      • Issue: Invalid AI provider
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • AI Data Analysis Orchestrator Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Default Mode
      • 2. Max Iterations
      • 3. Enable Auto Workflow
      • 4. Default AI Provider
      • 5. Enable Caching
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Performance Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Analysis Modes
      • Basic Modes
      • Advanced Modes
    • AI Providers
      • Supported Providers
      • Provider Configuration
    • Operations Supported
      • Basic Analysis
      • Advanced Analysis
      • Workflow Management
      • Tool Coordination
    • Troubleshooting
      • Issue: AI Provider not available
      • Issue: Analysis workflow fails
      • Issue: Max iterations exceeded
      • Issue: Caching problems
      • Issue: Auto workflow issues
      • Issue: Foundation tool errors
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • APISource Tool — removed in AIECS 2.0
  • APISource Tool — removed in AIECS 2.0
  • APISource Tool — removed in AIECS 2.0
  • Search Tool - Configuration Reference
    • Table of Contents
    • 1. Configuration Overview
      • 1.1 Configuration Methods
      • 1.2 Configuration Schema
    • 2. API Credentials
      • 2.1 Google API Key
      • 2.2 Google CSE ID
      • 2.3 Service Account Credentials
    • 3. Performance Settings
      • 3.1 Max Results Per Query
      • 3.2 Cache TTL
      • 3.3 Timeout
      • 3.4 User Agent
    • 4. Rate Limiting
      • 4.1 Rate Limit Requests
      • 4.2 Rate Limit Window
      • 4.3 Rate Limiting Algorithm
    • 5. Circuit Breaker
      • 5.1 Circuit Breaker Threshold
      • 5.2 Circuit Breaker Timeout
    • 6. Enhanced Features
      • 6.1 Quality Analysis
      • 6.2 Intent Analysis
      • 6.3 Deduplication
      • 6.4 Context Tracking
      • 6.5 Intelligent Cache
      • 6.6 Similarity Threshold
      • 6.7 Max Search History
    • 7. Caching Configuration
      • 7.1 Redis Configuration
      • 7.2 Cache Key Structure
      • 7.3 Cache Invalidation
    • 8. Environment Variables
      • 8.1 Complete Environment Variable List
      • 8.2 Environment Variable Naming
    • 9. Configuration Examples
      • 9.1 Development Configuration
      • 9.2 Production Configuration
      • 9.3 High-Volume Configuration
      • 9.4 Minimal Configuration
      • 9.5 Programmatic Configuration
    • 10. Validation & Testing
      • 10.1 Validate Configuration
      • 10.2 Test Configuration
      • 10.3 Configuration Checklist
  • Search Tool - Developer’s Guide
    • Table of Contents
    • 1. Quick Start
      • 1.1 5-Minute Setup
      • 1.2 First Search in 3 Lines
    • 2. Installation & Setup
      • 2.1 Prerequisites
      • 2.2 Google Custom Search Setup
      • 2.3 Environment Configuration
      • 2.4 Verify Setup
    • 3. Basic Usage
      • 3.1 Web Search
      • 3.2 Image Search
      • 3.3 News Search
      • 3.4 Video Search
      • 3.5 Pagination
      • 3.6 Batch Search
    • 4. Advanced Usage
      • 4.1 Quality Analysis
      • 4.2 Intent Analysis
      • 4.3 Result Summaries
      • 4.4 Search Context
      • 4.5 Monitoring & Metrics
    • 5. LangChain Integration
      • 5.1 Basic LangChain Usage
      • 5.2 Available LangChain Tools
      • 5.3 Custom LangChain Tool Selection
    • 6. Best Practices
      • 6.1 Performance Optimization
      • 6.2 Quota Management
      • 6.3 Error Handling
      • 6.4 Quality Assurance
    • 7. Common Patterns
      • 7.1 Research Assistant Pattern
      • 7.2 Content Aggregator Pattern
      • 7.3 News Monitor Pattern
      • 7.4 Smart Search Pattern
    • 8. Troubleshooting
      • 8.1 Common Issues
      • 8.2 Debug Mode
      • 8.3 Validation
    • 9. Examples
      • 9.1 Complete Example: Research Assistant
      • 9.2 Complete Example: News Aggregator
  • Search Tool - Complete Technical Documentation
    • Table of Contents
    • 1. Overview
      • 1.1 Purpose
      • 1.2 Key Capabilities
      • 1.3 Architecture Overview
    • 2. Architecture
      • 2.1 Package Structure
      • 2.2 Component Interaction Flow
      • 2.3 Integration Points
    • 3. Core Components
      • 3.1 SearchTool Class
      • 3.2 Rate Limiter
      • 3.3 Circuit Breaker
    • 4. Enhanced Features
      • 4.1 Result Quality Analyzer
      • 4.2 Query Intent Analyzer
      • 4.3 Result Deduplicator
      • 4.4 Search Context
      • 4.5 Intelligent Cache
      • 4.6 Enhanced Metrics
    • 5. API Reference
      • 5.1 Search Operations
        • search_web()
        • search_images()
        • search_news()
        • search_videos()
        • search_paginated()
        • search_batch()
      • 5.2 Monitoring Operations
        • get_metrics()
        • get_metrics_report()
        • get_health_score()
        • get_quota_status()
        • validate_credentials()
      • 5.3 Context Operations
        • get_search_context()
    • 6. Data Structures
      • 6.1 Enumerations
      • 6.2 Exception Hierarchy
    • 7. Error Handling
      • 7.1 Agent-Friendly Error Handler
      • 7.2 Error Handling Best Practices
    • 8. Performance & Optimization
      • 8.1 Performance Benchmarks
      • 8.2 Optimization Strategies
      • 8.3 Scalability Considerations
    • 9. Testing
      • 9.1 Unit Tests
      • 9.2 Integration Tests
    • 10. Advanced Topics
      • 10.1 Custom Quality Analyzers
      • 10.2 Custom Intent Patterns
      • 10.3 Custom Cache Strategies
      • 10.4 Monitoring Integration
  • Statistical Analyzer Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Significance Level
      • 2. Confidence Level
      • 3. Enable Effect Size
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Rigorous Analysis Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • Float Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Analysis Types
      • Descriptive Statistics
      • Hypothesis Testing
      • Regression Analysis
      • Correlation Analysis
      • Time Series Analysis
    • Operations Supported
      • Basic Analysis
      • Hypothesis Testing
      • Regression Analysis
      • Advanced Analysis
      • Statistical Tests
      • Reporting Operations
    • Troubleshooting
      • Issue: Statistical test assumptions not met
      • Issue: Insufficient sample size
      • Issue: Multiple comparison problems
      • Issue: Non-normal data
      • Issue: Missing data
      • Issue: Correlation vs causation
      • Issue: Effect size interpretation
    • Best Practices
      • Statistical Rigor
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Model Trainer Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Test Size
      • 2. Random State
      • 3. CV Folds
      • 4. Enable Hyperparameter Tuning
      • 5. Max Tuning Iterations
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Production Configuration with Tuning
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • Float Values
      • Integer Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Model Types
      • Classification Models
      • Regression Models
      • Auto Selection
    • Task Types
      • Classification
      • Regression
      • Clustering
    • Operations Supported
      • Basic Training
      • Hyperparameter Tuning
      • Model Evaluation
      • Feature Analysis
      • Model Management
      • Advanced Operations
    • Troubleshooting
      • Issue: Model training fails
      • Issue: Hyperparameter tuning takes too long
      • Issue: Cross-validation errors
      • Issue: Memory usage exceeded
      • Issue: Poor model performance
      • Issue: Non-reproducible results
      • Issue: Test set too small/large
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Data Visualizer Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Default Style
      • 2. Default Output Directory
      • 3. Default DPI
      • 4. Default Figure Size
      • 5. Enable Auto Recommendation
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Quality Production Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • List Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Chart Types
      • Basic Charts
      • Advanced Charts
      • Statistical Charts
      • Time Series
      • Auto-Detection
    • Visualization Styles
      • Static Style
      • Interactive Style
      • Animated Style
    • Operations Supported
      • Basic Visualization
      • Chart Type Operations
      • Advanced Visualization
      • Export Operations
      • Style Operations
      • Analysis Operations
    • Troubleshooting
      • Issue: Output directory not accessible
      • Issue: Visualization generation fails
      • Issue: Low image quality
      • Issue: Interactive visualizations not working
      • Issue: Auto recommendation not working
      • Issue: Memory usage exceeded
      • Issue: Slow visualization generation
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Data Transformer Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Outlier STD Threshold
      • 2. Default Missing Strategy
      • 3. Enable Pipeline Caching
      • 4. Max One Hot Categories
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Robust Production Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Float Values
      • Integer Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Transformation Types
      • Cleaning Operations
      • Transformation Operations
      • Encoding Operations
      • Feature Engineering
    • Missing Value Strategies
      • Statistical Strategies
      • Interpolation Strategies
      • Other Strategies
    • Operations Supported
      • Basic Transformations
      • Feature Engineering
      • Encoding Operations
      • Normalization and Scaling
      • Pipeline Operations
      • Advanced Operations
    • Troubleshooting
      • Issue: Outlier removal too aggressive
      • Issue: Missing value strategy fails
      • Issue: One-hot encoding creates too many columns
      • Issue: Pipeline caching issues
      • Issue: Transformation performance issues
      • Issue: Memory usage exceeded
      • Issue: Data type compatibility
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Data Profiler Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Default Profile Level
      • 2. Outlier STD Threshold
      • 3. Correlation Threshold
      • 4. Missing Threshold
      • 5. Enable Visualizations
      • 6. Max Unique Values Categorical
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Comprehensive Analysis Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Float Values
      • Integer Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Profile Levels
      • Basic Level
      • Standard Level
      • Comprehensive Level
      • Deep Level
    • Data Quality Checks
      • Missing Values
      • Duplicates
      • Outliers
      • Inconsistencies
      • Data Types
      • Distributions
      • Correlations
    • Operations Supported
      • Basic Profiling
      • Advanced Profiling
      • Quality Operations
      • Visualization Operations
      • Recommendation Operations
    • Troubleshooting
      • Issue: Profiling takes too long
      • Issue: Memory usage exceeded
      • Issue: Too many outliers detected
      • Issue: Missing correlation detection
      • Issue: Categorical analysis issues
      • Issue: Visualization generation fails
      • Issue: Quality assessment too strict
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Data Loader Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Max File Size MB
      • 2. Default Chunk Size
      • 3. Max Memory Usage MB
      • 4. Enable Schema Inference
      • 5. Enable Quality Validation
      • 6. Default Encoding
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Performance Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Data Source Types
      • Text Formats
      • Binary Formats
      • Statistical Formats
      • Auto-Detection
    • Loading Strategies
      • Full Load
      • Streaming
      • Chunked
      • Lazy
      • Incremental
    • Operations Supported
      • Basic Loading
      • Advanced Loading
      • Schema Operations
      • Quality Operations
      • Utility Operations
    • Troubleshooting
      • Issue: File too large error
      • Issue: Memory usage exceeded
      • Issue: Schema inference fails
      • Issue: Quality validation fails
      • Issue: Encoding problems
      • Issue: Chunked loading performance
      • Issue: File format not supported
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • AI Report Orchestrator Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Default Report Type
      • 2. Default Format
      • 3. Output Directory
      • 4. Include Code
      • 5. Include Visualizations
      • 6. Max Insights Per Report
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Professional Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Report Types
      • Business Reports
      • Technical Reports
    • Report Formats
      • Document Formats
      • Data Formats
    • Operations Supported
      • Basic Report Generation
      • Advanced Report Operations
      • Report Management
      • Integration Operations
    • Troubleshooting
      • Issue: Output directory not accessible
      • Issue: Report generation fails
      • Issue: Visualizations not included
      • Issue: Reports too long or too short
      • Issue: Format conversion fails
      • Issue: Code inclusion problems
      • Issue: Performance issues
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • AI Insight Generator Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Min Confidence
      • 2. Anomaly Std Threshold
      • 3. Correlation Threshold
      • 4. Enable Reasoning
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Accuracy Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • Float Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Insight Types
      • Basic Insights
      • Advanced Insights
    • Operations Supported
      • Basic Insight Generation
      • Advanced Analysis
      • Reasoning Integration
      • Utility Operations
    • Troubleshooting
      • Issue: Low confidence insights
      • Issue: Too many anomalies detected
      • Issue: Weak correlations found
      • Issue: Reasoning methods not available
      • Issue: Insight generation fails
      • Issue: Performance issues
    • Best Practices
      • Performance Optimization
      • Error Handling
      • Security
      • Resource Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Document Creator Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Templates Directory
      • 2. Output Directory
      • 3. Default Format
      • 4. Default Style
      • 5. Auto Backup
      • 6. Include Metadata
      • 7. Generate Table of Contents
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Academic Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Boolean Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Document Types
      • Business Documents
      • Academic Documents
      • Creative Documents
      • Reference Documents
    • Supported Formats
      • Text Formats
      • Document Formats
      • Data Formats
    • Template Types
      • Built-in Templates
      • Template Structure
    • Style Presets
      • Professional Styles
      • Design Styles
      • Style Features
    • Operations Supported
      • Document Creation
      • Template Management
      • Document Structure
      • Metadata Management
      • Style and Formatting
      • Document Management
      • Batch Operations
    • Troubleshooting
      • Issue: Directory not accessible
      • Issue: Template not found
      • Issue: Format conversion fails
      • Issue: Style not applied
      • Issue: Metadata validation fails
      • Issue: TOC generation fails
      • Issue: Backup creation fails
    • Best Practices
      • Template Organization
      • Document Management
      • Style Consistency
      • Performance Optimization
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Report Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Templates Directory
      • 2. Default Output Directory
      • 3. Allowed Extensions
      • 4. PDF Page Size
      • 5. Default Font
      • 6. Default Font Size
      • 7. Allowed HTML Tags
      • 8. Allowed HTML Attributes
      • 9. Temp Files Max Age
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Security-Focused Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • List Values
      • Set Values
      • Dictionary Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Operations Supported
      • HTML Reports
      • Excel Reports
      • PowerPoint Reports
      • Markdown Reports
      • Word Reports
      • Image Reports
      • Batch Processing
      • PDF Reports (Currently Disabled)
    • Troubleshooting
      • Issue: Template not found
      • Issue: Output directory not writable
      • Issue: HTML sanitization too strict
      • Issue: File extension not allowed
      • Issue: Font not available
      • Issue: Memory issues with large reports
      • Issue: PDF generation error
      • Issue: Dictionary parsing error
      • Issue: List parsing error
    • Best Practices
      • Security
      • Performance
      • Template Management
      • Error Handling
      • Development vs Production
      • Template Examples
    • Related Documentation
    • Support
  • Chart Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Export Directory
      • 2. Plot DPI
      • 3. Plot Figure Size
      • 4. Allowed Extensions
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Programmatic Configuration
      • Example 3: Mixed Configuration
    • Configuration Priority
    • Validation
      • Type Validation
      • Runtime Validation
    • Best Practices
    • Troubleshooting
      • Issue: Exports not found
      • Issue: Environment variable not recognized
      • Issue: Invalid figure size
    • Related Tools
    • Support
  • ChartTool LangChain Agent Usage Guide
    • Overview
    • Available Tools List
    • 1. chart_read_data
      • Function Description
      • Supported File Formats
      • LangChain Invocation Method
      • Input Parameters
      • Use Cases
      • Return Result
      • Agent Invocation Example
    • 2. chart_visualize
      • Function Description
      • Supported Chart Types
      • LangChain Invocation Method
      • Input Parameters
      • Use Cases
        • 📈 Trend Analysis
        • 📊 Distribution Analysis
        • 🔗 Relationship Analysis
        • 🔥 Correlation Analysis
        • 📦 Categorical Comparison
      • Return Result
      • Agent Invocation Example
    • 3. chart_export_data
      • Function Description
      • Supported Export Formats
      • LangChain Invocation Method
      • Input Parameters
      • Use Cases
        • 📄 Format Conversion
        • 🎯 Selective Data Export
        • 📊 Report Generation
        • 💾 Data Backup
      • Return Result
      • Agent Invocation Example
    • Complete Workflow Example
      • Scenario: Complete Data Analysis Workflow
    • Advanced Usage Tips
      • 1. Batch Analysis of Multiple Files
      • 2. Create Comparison Charts
      • 3. Correlation Analysis
      • 4. Custom Output Configuration
    • Error Handling
      • Common Errors and Solutions
      • Best Practices
    • Configuration Options
    • Performance Optimization Recommendations
    • Summary
  • Classifier Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Max Workers
      • 2. Pipeline Cache TTL
      • 3. Pipeline Cache Size
      • 4. Max Text Length
      • 5. SpaCy Model (English)
      • 6. SpaCy Model (Chinese)
      • 7. Allowed Models
      • 8. Rate Limit Enabled
      • 9. Rate Limit Requests
      • 10. Rate Limit Window
      • 11. Use RAKE for English
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Development Environment
      • Example 3: Production Environment
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • Boolean Values
      • List Values
      • Integer Values
    • Validation
      • Automatic Type Validation
      • Custom Validation
      • Security Validation
    • Performance Tuning
      • Memory Optimization
      • Speed Optimization
      • Accuracy Optimization
    • Model Installation
    • Troubleshooting
      • Issue: Model not found
      • Issue: Rate limit exceeded
      • Issue: Out of memory
      • Issue: Boolean environment variable not working
      • Issue: List parsing error
    • Best Practices
    • Operations Supported
    • Related Documentation
    • Support
  • Content Insertion Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Temp Directory
      • 2. Assets Directory
      • 3. Max Image Size
      • 4. Max Chart Size
      • 5. Default Image Format
      • 6. Optimize Images
      • 7. Auto Resize
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Quality Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Boolean Values
      • Tuple Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Operations Supported
      • Chart Insertion
      • Table Insertion
      • Image Insertion
      • Media Insertion
      • Interactive Elements
      • Document Elements
      • Content Management
      • Batch Operations
    • Troubleshooting
      • Issue: Directory not writable
      • Issue: Image too large
      • Issue: Chart generation fails
      • Issue: External tool not available
      • Issue: Tuple parsing error
      • Issue: Boolean parsing error
      • Issue: Memory errors with large content
      • Issue: Content insertion fails
    • Best Practices
      • Performance Optimization
      • Content Quality
      • Asset Management
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Document Layout Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Temp Directory
      • 2. Default Page Size
      • 3. Default Orientation
      • 4. Default Margins
      • 5. Auto Adjust Layout
      • 6. Preserve Formatting
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Professional Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Boolean Values
      • Dict Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Page Sizes
      • Standard Sizes
      • US Sizes
      • Custom Sizes
    • Orientations
      • Portrait
      • Landscape
    • Layout Types
      • Column Layouts
      • Specialized Layouts
    • Layout Presets
      • Built-in Presets
      • Preset Features
    • Operations Supported
      • Page Setup
      • Multi-Column Layouts
      • Headers and Footers
      • Typography and Spacing
      • Break Management
      • Layout Optimization
      • Batch Operations
    • Troubleshooting
      • Issue: Directory not accessible
      • Issue: Page size not supported
      • Issue: Margin validation fails
      • Issue: Layout application fails
      • Issue: Formatting not preserved
      • Issue: Dict parsing error
      • Issue: Layout optimization fails
    • Best Practices
      • Layout Consistency
      • Responsive Design
      • Format Compatibility
      • Performance Optimization
      • Integration
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • Optional Dependencies
      • Verification
    • Related Documentation
    • Support
  • Image Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Max File Size (MB)
      • 2. Allowed Extensions
      • 3. Tesseract Pool Size
      • 4. Default OCR Language
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Security-Focused Configuration
      • Example 3: High-Performance Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
      • Example 6: Dynamic Configuration Update
    • Configuration Priority
    • Data Type Parsing
      • Integer Values
      • List Values
    • Validation
      • Automatic Type Validation
      • File Validation
      • Security Validation
    • Tesseract Setup
      • Installation
      • Language Data
      • Verify Installation
      • Using OCR with Different Languages
    • Operations Supported
      • 1. Load
      • 2. OCR (Optical Character Recognition)
      • 3. Metadata
      • 4. Resize
      • 5. Filter
    • Troubleshooting
      • Issue: File size validation fails
      • Issue: Extension not allowed
      • Issue: Tesseract not found
      • Issue: OCR returns empty or garbled text
      • Issue: Pool size too small for concurrent requests
      • Issue: List parsing error
      • Issue: Memory issues with large images
    • Best Practices
      • Security
      • Performance
      • Development vs Production
      • Error Handling
    • Related Documentation
    • Support
  • Office Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Max File Size (MB)
      • 2. Default Font
      • 3. Default Font Size
      • 4. Allowed Extensions
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Security-Focused Configuration
      • Example 3: High-Capacity Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • Integer Values
      • String Values
      • List Values
    • Validation
      • Automatic Type Validation
      • File Validation
      • Security Validation
    • Dependencies Setup
      • Required Python Packages
      • Apache Tika Setup
      • Tesseract OCR Setup
      • Language Data
      • Java Runtime
    • Operations Supported
      • 1. Read DOCX
      • 2. Write DOCX
      • 3. Read PPTX
      • 4. Write PPTX
      • 5. Read XLSX
      • 6. Write XLSX
      • 7. Extract Text
    • Troubleshooting
      • Issue: File size validation fails
      • Issue: Extension not allowed
      • Issue: Tika server not starting
      • Issue: Tesseract not found
      • Issue: Font not found in generated documents
      • Issue: Path not in allowed directories
      • Issue: List parsing error
      • Issue: Memory issues with large documents
      • Issue: Corrupted document
    • Best Practices
      • Security
      • Performance
      • Document Quality
      • Development vs Production
      • Error Handling
    • Related Documentation
    • Support
  • Pandas Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. CSV Delimiter
      • 2. Encoding
      • 3. Default Aggregation
      • 4. Chunk Size
      • 5. Max CSV Size
      • 6. Allowed File Extensions
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Performance Configuration
      • Example 3: Memory-Constrained Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • Dictionary Values
      • List Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Operations Supported
      • Data Reading/Writing
      • Descriptive Statistics
      • Filtering and Selection
      • Grouping and Aggregation
      • Merging and Concatenation
      • Data Transformation
      • Data Reshaping
      • Data Cleaning
      • Statistical Computations
      • Window Functions
      • Sampling and Viewing
    • Troubleshooting
      • Issue: CSV parsing fails
      • Issue: Memory errors with large files
      • Issue: File extension not allowed
      • Issue: Dictionary parsing error
      • Issue: List parsing error
      • Issue: Encoding errors
      • Issue: Performance issues
      • Issue: Column not found
    • Best Practices
      • Performance Optimization
      • Memory Management
      • Data Quality
      • Security
      • Development vs Production
      • Error Handling
    • Related Documentation
    • Support
  • Research Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Max Workers
      • 2. SpaCy Model
      • 3. Max Text Length
      • 4. Allowed SpaCy Models
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: High-Performance Configuration
      • Example 3: Multilingual Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • String Values
      • Integer Values
      • List Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Operations Supported
      • Mill’s Methods for Causal Inference
        • Method of Agreement
        • Method of Difference
        • Joint Method
        • Method of Residues
        • Method of Concomitant Variations
      • Advanced Analysis Operations
        • Induction
        • Deduction
        • Text Summarization
    • Troubleshooting
      • Issue: SpaCy model not found
      • Issue: Model not in allowed list
      • Issue: Memory errors with large texts
      • Issue: Slow processing
      • Issue: Correlation analysis fails
      • Issue: List parsing error
      • Issue: Text too long
    • Best Practices
      • Performance Optimization
      • Causal Inference Best Practices
      • Text Analysis Best Practices
      • Security
      • Development vs Production
      • Error Handling
    • SpaCy Model Installation
      • Installing Models
      • Verifying Installation
      • Model Information
    • Related Documentation
    • Support
  • Scraper Tool — removed in AIECS 2.0
  • Stats Tool Configuration Guide
    • Overview
    • Using .env Files in Your Project
      • Setting Up .env Files
      • Multiple Environment Files
      • Best Practices for .env Files
    • Configuration Options
      • 1. Max File Size MB
      • 2. Allowed Extensions
    • Usage Examples
      • Example 1: Basic Environment Configuration
      • Example 2: Production Configuration
      • Example 3: Development Configuration
      • Example 4: Programmatic Configuration
      • Example 5: Mixed Configuration
    • Configuration Priority
    • Data Type Parsing
      • Integer Values
      • List Values
    • Validation
      • Automatic Type Validation
      • Runtime Validation
    • Operations Supported
      • Data Loading and Inspection
      • Descriptive Statistics
      • Hypothesis Testing
      • Correlation Analysis
      • Regression Analysis
      • Advanced Statistical Operations
      • Data Transformation
    • Troubleshooting
      • Issue: File format not supported
      • Issue: File too large
      • Issue: Missing dependencies
      • Issue: Memory errors
      • Issue: Statistical computation errors
      • Issue: Variable not found
      • Issue: List parsing error
      • Issue: SPSS file reading errors
    • Best Practices
      • Data Quality
      • Statistical Analysis
      • Performance
      • Security
      • Development vs Production
      • Error Handling
    • Dependencies
      • Core Dependencies
      • SPSS/SAS Support
      • Excel Support
      • Parquet/Feather Support
      • Verification
    • Statistical Interpretation Guide
      • Effect Sizes
      • P-value Interpretation
      • Sample Size Guidelines
    • Related Documentation
    • Support
  • AIECS Statistics and Data Analysis Tools
    • Overview
    • Tool Registry
      • Foundation Tools
        • 1. DataLoaderTool (data_loader)
        • 2. DataProfilerTool (data_profiler)
        • 3. DataTransformerTool (data_transformer)
        • 4. DataVisualizerTool (data_visualizer)
        • 5. StatisticalAnalyzerTool (statistical_analyzer)
        • 6. ModelTrainerTool (model_trainer)
      • AI Orchestration Tools
        • 7. AIDataAnalysisOrchestrator (ai_data_analysis_orchestrator)
        • 8. AIInsightGeneratorTool (ai_insight_generator)
        • 9. AIReportOrchestratorTool (ai_report_orchestrator)
    • Architecture Alignment
    • Usage Examples
      • Example 1: Load and Profile Data
      • Example 2: Auto-Transform and Train Model
      • Example 3: Complete Analysis Workflow
    • Dependencies
    • Testing
    • Future Enhancements
      • AI Integration (Structured for Implementation)
      • Additional Features
    • Quality Metrics
    • File Structure
    • Contributing
    • License
  • AIECS Document Creation System Architecture
    • 📋 Overview
    • 🎯 Architecture Design Principles
      • 1. Atomic Tool Design
      • 2. AI-Driven Intelligent Orchestration
      • 3. Extensibility and Integration
    • 🏗️ Core Components
      • Component 1: DocumentCreatorTool (Document Creation Tool)
      • Component 2: DocumentLayoutTool (Layout & Formatting Tool)
      • Component 3: ContentInsertionTool (Content Insertion Tool)
      • Component 4: AIDocumentWriterOrchestrator (AI Document Orchestrator)
      • Component 5: DocumentWriterTool (Document Writer Tool)
    • 🔄 Complete Workflow
      • Standard Document Creation Workflow
      • AI-Driven Quick Creation Workflow
    • 🎯 Architecture Advantages
      • 1. Modularity and Maintainability
      • 2. Flexibility and Extensibility
      • 3. AI-Driven Intelligence
      • 4. Production-Grade Features
      • 5. Developer Friendly
    • 📊 Component Comparison
    • 🔧 Tool Integration Matrix
    • 💡 Use Cases
      • Case 1: Simple Document Creation
      • Case 2: Professional Layout Document
      • Case 3: Rich Media Document
      • Case 4: AI-Driven Intelligent Document
      • Case 5: Data-Driven Report
    • 🚀 Quick Start
      • Simplest Way (Recommended)
      • Standalone Tool Usage
    • 📈 Performance and Best Practices
      • Performance Optimization Recommendations
      • Best Practices
    • 🎓 Summary
    • 📚 Related Documentation
  • AIECS Document Creation System - Quick Reference
    • 🚀 Quick Start
      • Simplest Way (One Line of Code)
    • 📋 5 Core Tools
    • 🎯 Common Operations Quick Reference
      • 1. Create Document
      • 2. Configure Layout
      • 3. Insert Chart
      • 4. Insert Table
      • 5. Text Editing
      • 6. AI Enhancement
    • 🔄 Typical Workflows
      • Workflow 1: Basic Document (No AI)
      • Workflow 2: Professional Document (With Layout)
      • Workflow 3: Rich Media Document (With Charts & Tables)
      • Workflow 4: AI Intelligent Document (Fully Automated)
    • 📊 Feature Comparison
    • 🎨 Supported Formats
      • Output Formats (11 types)
      • Chart Types (10 types)
      • Table Styles (8 types)
      • Document Templates (9 types)
      • Layout Presets (10 types)
    • ⚙️ Configuration Options
      • Page Sizes
      • Page Orientation
      • Alignment
      • Image Alignment
      • Write Modes (9 types)
    • 💡 Practical Tips
      • Tip 1: Choose the Right Tool
      • Tip 2: Use Templates
      • Tip 3: Batch Operations
      • Tip 4: Enable Backup
      • Tip 5: Use AI Optimization
    • 🔍 Common Questions
      • Q: How to choose which tool to use?
      • Q: How do tools work together?
      • Q: Which cloud storage is supported?
      • Q: How to handle large files?
      • Q: What’s needed for AI features?
    • 📚 More Resources
    • 🎯 Quick Reference Code Snippets
      • Create Business Report
      • Add Chart
      • AI Optimize Document
      • Batch Content
  • Document Writer Tool - Modern High-Performance Document Writing Component
    • Overview
    • 🏗️ Component Architecture
    • 🎯 Core Features
      • 1. Production-Grade Write Operations
      • 2. Multi-Format Document Support
      • 3. Multiple Write Modes
      • 4. Enterprise-Level Security
      • 5. AI Intelligent Writing
    • 📝 Usage Methods
      • 1. Basic Document Writing
      • 2. Different Write Modes
      • 3. Multi-Format Document Writing
      • 4. Cloud Storage Document Writing
      • 5. AI Intelligent Writing
      • 6. Content Enhancement and Rewriting
      • 7. Batch Write Operations
      • 8. Template-Based Document Generation
    • ⚙️ Configuration Options
      • DocumentWriterTool Configuration
      • AIDocumentWriterOrchestrator Configuration
    • 🔒 Security and Validation
      • 1. Content Validation Levels
      • 2. Permission and Security Checks
    • 📊 Production-Grade Features
      • 1. Atomic Operations
      • 2. Transactional Batch Operations
      • 3. Automatic Backup and Version Control
      • 4. Auditing and Monitoring
    • 🔄 Write Strategy Details
      • 1. CREATE vs OVERWRITE
      • 2. APPEND vs UPDATE
      • 3. Backup Strategy
    • 🚨 Error Handling and Rollback
      • Common Error Types
      • Rollback Operations
    • 📈 Performance Optimization
      • 1. Large File Processing
      • 2. Concurrent Write Control
    • 🎯 Best Practices
      • 1. Production Environment Configuration
      • 2. Error Handling Strategy
      • 3. Monitoring and Logging
    • 🔮 Advanced Features
      • 1. Custom Format Converters
      • 2. Plugin-Style Validators
    • 📚 Summary
  • Document Parser Tool - Modern High-Performance Document Parsing Component
    • Overview
    • 🏗️ New Directory Structure
    • Core Features
      • 1. Intelligent Document Type Detection
      • 2. Multi-Source Document Retrieval
      • 3. Diverse Parsing Strategies
      • 4. AI Intelligent Orchestration
      • 5.1 High-Performance Architecture
    • Architecture Design
      • Component Architecture
      • Workflow
    • Usage Methods
      • 1. Basic Document Parsing (New Import Path)
      • 1.1 Cloud Storage Document Parsing
      • 2. Document Type Detection
      • 3. AI Intelligent Analysis (New Import Path)
      • 4. Batch Processing
      • 5. Custom Processing Flow
    • Configuration Options
      • DocumentParserTool Configuration
      • AIDocumentOrchestrator Configuration
    • Supported Document Formats
    • Cloud Storage Support
      • Supported Cloud Storage Formats
      • Cloud Storage Configuration Examples
    • AI Processing Modes
      • 1. Document Summarization (SUMMARIZE)
      • 2. Information Extraction (EXTRACT_INFO)
      • 3. Content Analysis (ANALYZE)
      • 4. Document Translation (TRANSLATE)
      • 5. Document Classification (CLASSIFY)
      • 6. Q&A System (ANSWER_QUESTIONS)
    • Performance Optimization
      • 1. Caching Strategy
      • 2. Concurrent Processing
      • 3. Memory Management
      • 4. Error Handling
    • Error Handling
      • Common Error Types
      • Error Handling Example
    • Migration Guide
      • Migrating from Old Version
      • Batch Update Script
    • Extension Development
      • 1. Add New Document Format Support
      • 2. Custom AI Processing Templates
      • 3. Integrate New AI Provider
    • Best Practices
      • 1. Document Processing
      • 2. AI Processing
      • 3. Error Handling
      • 4. Performance Optimization
    • Out-of-the-Box Check
    • Quick Start
    • Example Code
    • Future Plans
  • Document Parser Tool - Quick Start Guide
    • 🚀 Ready to Use
    • 📁 New Directory Structure
    • 🔧 Installation and Configuration
      • 1. Basic Installation
      • 2. Environment Variable Configuration (Optional)
    • 💻 Basic Usage
      • 1. Import Tools (New Path)
      • 2. Quick Start Example
      • 3. Supported Document Sources
    • 🌐 Cloud Storage Configuration
      • Google Cloud Storage
      • Process Cloud Storage Documents
    • 🎯 Real-World Application Examples
      • 1. Batch Process Documents
      • 2. Custom AI Analysis
      • 3. Real-time Document Processing
    • 🔍 Troubleshooting
      • Common Issues and Solutions
        • 1. Import Errors
        • 2. Permission Issues
        • 3. Cloud Storage Configuration
    • 📊 Feature Checklist
    • 🚀 Production Deployment Recommendations
      • 1. Performance Configuration
      • 2. Error Handling
      • 3. Monitoring and Logging
    • 📚 More Resources
    • 🎯 Summary
  • Tools Architecture
    • Directory Structure
    • New Architecture
    • Tool Categories
      • Task Tools
    • Using Base Tool Class
    • Using Decorators for Performance Optimization
    • Migrating Existing Tools
      • Before:
      • After:
    • Benefits of the New Architecture
    • Usage Examples
    • Multi-Task Service Integration
    • Task Tool Usage Examples
      • Data Processing Pipeline
      • Research and Information Gathering
      • Office Document Processing
    • Tool Discovery and Registration
    • Best Practices
      • 1. Tool Composition
      • 2. Error Handling
      • 3. Asynchronous Operations
    • Extending the Tool System
      • Adding New Task Tools
      • Creating New Tool Categories
    • Special Tool Usage Instructions
      • Image Tool
        • System Dependency Requirements
        • 1. Tesseract OCR Engine
        • 2. Pillow Image Processing Library System Dependencies
        • 3. Multi-language OCR Support
        • Features
        • Usage Examples
        • Security Features
      • ClassFire Tool (Text Classification and Keyword Extraction Tool)
        • Model Dependency Requirements
        • 1. spaCy Model Dependencies
        • 2. Transformers Model Dependencies
        • 3. NLTK Data Package Dependencies
        • Features
        • Usage Examples
        • Performance Optimization
        • Notes
      • Office Tool (Office Document Processing Tool)
        • System Dependency Requirements
        • 1. Java Runtime Environment (Required)
        • 2. Tesseract OCR Engine (Required for OCR Functionality)
        • 3. Python Package Dependencies
        • Features
        • Usage Examples
        • OCR Functionality
        • Performance Optimization
        • Notes
      • Stats Tool (Statistical Analysis Tool)
        • System Dependency Requirements
        • 1. pyreadstat System Dependencies (Special File Format Support)
        • 2. Excel File Support System Dependencies
        • 3. Python Package Dependencies
        • Features
        • Supported File Formats
        • Usage Examples
        • Environment Variable Configuration
        • Troubleshooting
        • pyreadstat Installation Issues
        • Excel File Reading Issues
        • Memory Usage Issues
        • File Permission Issues
      • Report Tool (Multi-format Report Generation Tool)
        • System Dependency Requirements
        • 1. WeasyPrint System Dependencies (Required for PDF Functionality)
        • 2. Matplotlib System Dependencies (Required for Chart Functionality)
        • 3. Python Package Dependencies
        • Features
        • Usage Examples
        • PDF Functionality Notes
        • Performance Optimization
        • Notes
    • Scraper Tool (Web Scraping Tool)
      • Feature Overview
      • Special Dependency Instructions
        • 1. Playwright Browser Dependencies
        • 2. Scrapy Advanced Crawling Dependencies
        • 3. Other Dependencies
      • Usage Examples
        • Basic HTTP Requests (No Browser Required)
        • JavaScript Rendering (Requires Playwright)
        • Advanced Crawling (Requires Scrapy)
      • Feature Classification
      • Notes
        • Playwright Related
        • Scrapy Related
        • General Notes
      • Troubleshooting
        • Playwright Issues
        • Scrapy Issues
        • Network Issues
  • Tool Executor TTL Strategies Guide
    • Overview
    • Core Features
      • 1. Multiple TTL Strategy Types
      • 2. Decorator Support
    • TTL Strategy Function Signature
      • Standard Signature
      • Parameter Description
    • Practical Examples
      • Example 1: SearchTool Intelligent TTL
      • Example 2: TTL Based on Data Type
      • Example 3: TTL Based on Query Parameters
    • Integration with Dual-Layer Cache
      • Configure Dual-Layer Cache
      • Cache Flow
      • L1 and L2 TTL Strategies
    • Best Practices
      • 1. Return Value Design
      • 2. TTL Strategy Function Design
      • 3. Cache Key Generation
    • Monitoring and Debugging
      • Get Cache Statistics
      • Logging
    • Summary
      • Advantages
      • Applicable Scenarios
      • Next Steps
  • Tool Naming Convention
    • 📋 Core Rules
    • ✅ Correct Tool Names
      • Format Rules
      • Complete Tool Name List
    • 📝 Usage Examples
      • 1. Get Tool in Python Code
      • 2. Get LangChain Tools
      • 3. Specify Tools in Configuration Files
        • YAML Configuration Example
        • JSON Configuration Example
        • Python Configuration Example
      • 4. Create LangChain Agent
    • ❌ Common Errors
      • Error 1: Using Class Name Instead of Tool Name
      • Error 2: Using Uppercase Letters
      • Error 3: Adding Tool Suffix
      • Error 4: Using CamelCase
    • 🔍 How to View All Available Tool Names
      • Method 1: Use list_tools()
      • Method 2: Use TOOL_CLASSES
      • Method 3: Use Command Line
    • 📚 Naming Convention Explanation
      • Why Use Lowercase + Underscore?
      • Class Name vs Tool Name
    • 🎯 Quick Reference
      • Common Tool Names Quick Reference
    • ✅ Verify Tool Name
    • 📖 Related Documentation
  • Tool Executor Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Decorator System
      • 4.2 Intelligent Caching System
      • 4.3 Concurrency Control Mechanism
      • 4.4 Security Protection Mechanism
      • 4.5 Performance Monitoring and Metrics Collection
    • 5. API Reference
      • 5.1 ToolExecutor Class
        • Constructor
        • Core Methods
      • 5.2 Decorator Functions
        • validate_input
        • cache_result
        • run_in_executor
        • measure_execution_time
        • sanitize_input
      • 5.3 Exception Classes
        • ToolExecutionError
        • InputValidationError
        • SecurityError
        • OperationError
        • TimeoutError
      • 5.4 Configuration Class
        • ExecutorConfig
    • 6. Technical Implementation Details
      • 6.1 Decorator Pattern Implementation
      • 6.2 Cache Key Generation Strategy
      • 6.3 Concurrency Control Mechanism
      • 6.4 Security Protection Mechanism
      • 6.5 Error Handling Mechanism
      • 6.6 Performance Monitoring Mechanism
    • 7. Configuration & Deployment
      • 7.1 Environment Variable Configuration
      • 7.2 Dependency Management
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues and Solutions
        • 8.2.1 Thread Pool Exhaustion
        • 8.2.2 Cache Performance Issues
        • 8.2.3 Security Check False Positives
      • 8.3 Performance Optimization
      • 8.4 Log Analysis
    • 9. Visualizations
      • 9.1 Executor Architecture Diagram
      • 9.2 Execution Flow Diagram
      • 9.3 Concurrency Control Diagram
      • 9.4 Performance Monitoring Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation
      • B. Example Code
      • C. Technical Support
  • Temporary File Manager Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 File Registration and Tracking
      • 4.2 Automatic Cleanup Mechanism
      • 4.3 File Status Query
      • 4.4 Batch Operation Support
    • 5. API Reference
      • 5.1 TempFileManager Class
        • Constructor
        • Core Methods
      • 5.2 Attributes
        • base_dir
        • max_age
        • files
        • lock
    • 6. Technical Implementation Details
      • 6.1 Thread Safety Mechanism
      • 6.2 Path Processing Mechanism
      • 6.3 Time Management Strategy
      • 6.4 Error Handling Mechanism
      • 6.5 Memory Management
    • 7. Configuration & Deployment
      • 7.1 Environment Variable Configuration
      • 7.2 Dependency Management
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues and Solutions
        • 8.2.1 File Cleanup Failure
        • 8.2.2 High Memory Usage
        • 8.2.3 Concurrent Access Issues
      • 8.3 Performance Optimization
      • 8.4 Log Analysis
    • 9. Visualizations
      • 9.1 File Lifecycle Diagram
      • 9.2 System Architecture Diagram
      • 9.3 Concurrent Access Diagram
      • 9.4 Performance Monitoring Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation
      • B. Example Code
      • C. Technical Support
  • LangChain Adapter Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Automatic Tool Discovery and Conversion
      • 4.2 Intelligent Description Generation
      • 4.3 Compatibility Check and Graceful Degradation
      • 4.4 Batch Tool Management
    • 5. API Reference
      • 5.1 LangchainToolAdapter Class
        • Constructor
        • Core Methods
      • 5.2 ToolRegistry Class
        • Constructor
        • Core Methods
      • 5.3 Convenience Functions
        • get_langchain_tools
        • create_react_agent_tools
        • create_tool_calling_agent_tools
        • check_langchain_compatibility
    • 6. Technical Implementation Details
      • 6.1 Automatic Discovery Mechanism
      • 6.2 Intelligent Description Generation
      • 6.3 Compatibility Handling
      • 6.4 Tool Instance Management
      • 6.5 Error Handling and Logging
    • 7. Configuration & Deployment
      • 7.1 Environment Variable Configuration
      • 7.2 Dependency Management
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues and Solutions
        • 8.2.1 LangChain Dependency Missing
        • 8.2.2 Tool Discovery Failure
        • 8.2.3 Schema Validation Failure
        • 8.2.4 Performance Issues
      • 8.3 Log Analysis
      • 8.4 Testing Strategy
    • 9. Visualizations
      • 9.1 Adapter Architecture Diagram
      • 9.2 Tool Conversion Flow Diagram
      • 9.3 Execution Flow Diagram
      • 9.4 Compatibility Check Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation
      • B. Example Code
      • C. Technical Support
  • Base Tool Class Technical Documentation
    • 1. Overview
    • 2. Problem Background and Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning and Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features and Use Cases
      • 4.1 Input Validation and Security Protection
      • 4.2 Intelligent Caching System
      • 4.3 Asynchronous Concurrent Processing
      • 4.4 Performance Monitoring and Metrics Collection
    • 5. API Reference
      • 5.1 BaseTool Class
        • Constructor
        • Core Methods
      • 5.2 Decorators
        • validate_input
        • cache_result
        • run_in_executor
        • measure_execution_time
        • sanitize_input
      • 5.3 Internal Methods
        • _register_schemas
        • _register_async_methods
        • _sanitize_kwargs
    • 6. Technical Implementation Details
      • 6.1 Decorator Pattern Implementation
      • 6.2 Automatic Schema Registration Mechanism
      • 6.3 Cache Key Generation Strategy
      • 6.4 Security Protection Mechanism
      • 6.5 Asynchronous Execution Mechanism
    • 7. Configuration and Deployment
      • 7.1 Environment Variable Configuration
      • 7.2 Dependency Management
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance and Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues and Solutions
        • 8.2.1 Input Validation Failure
        • 8.2.2 Cache Issues
        • 8.2.3 Performance Issues
      • 8.3 Log Analysis
      • 8.4 Testing Strategy
    • 9. Visualizations
      • 9.1 Architecture Flow Diagram
      • 9.2 Decorator Composition Diagram
      • 9.3 Cache Strategy Diagram
      • 9.4 Performance Monitoring Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation
      • B. Example Code
      • C. Technical Support
  • Schema Auto-Generator Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
    • 4. Core Features & Implementation
      • 4.1 Feature List
      • 4.2 Core Implementation
        • 4.2.1 Type Annotation Extraction
        • 4.2.2 Docstring Parsing
        • 4.2.3 Type Normalization
    • 5. Usage Guide
      • 5.1 Basic Usage
      • 5.2 Batch Generation
      • 5.3 LangChain Integration
      • 5.4 Tool Development Validation
    • 6. Configuration & Extension
      • 6.1 Configuration Options
      • 6.2 Extension Points
    • 7. Performance & Quality Metrics
      • 7.1 Coverage Statistics
      • 7.2 Performance Metrics
      • 7.3 Quality Improvements
    • 8. Best Practices
      • 8.1 Tool Development Recommendations
      • 8.2 Validation Process
      • 8.3 Common Questions
    • 9. Troubleshooting
      • 9.1 Common Errors
      • 9.2 Debugging Tips
    • 10. Future Plans
      • 10.1 Short-term Plans
      • 10.2 Long-term Vision
    • 11. References

LLM Integration

  • LLM Model Configuration Management
    • Overview
    • Features
    • Architecture
      • Configuration Files
        • Main Configuration
      • Configuration Schema
    • Usage
      • Loading Configuration
      • Hot Reloading Configuration
      • Using Configured Models
      • Validating Configuration
    • Configuration Management
      • Adding a New Model
      • Adding Model Aliases
      • Updating Model Costs
    • Configuration Validation
    • Environment Variables
      • LLM_MODELS_CONFIG
      • In .env file
    • API Reference
      • LLMConfigLoader
      • Configuration Models
    • Best Practices
    • Troubleshooting
      • Configuration Not Found
      • Validation Errors
      • Model Not Found
    • Migration Guide
    • Examples
      • Complete Provider Configuration
      • Programmatic Access
    • Support
  • Custom LLM Client Integration
    • Overview
    • LLMClientProtocol Interface
    • Implementing a Custom LLM Client
      • Example 1: Local Model Client (Ollama)
      • Example 2: Custom Embedding Client
    • Registering Custom Providers
    • Configuration-Driven Usage
      • Entity Extraction Configuration
      • RAG Strategy Selection Configuration
      • Embedding Configuration
    • Cost Optimization Example
    • Best Practices
    • Troubleshooting
      • Client Not Found
      • Settings Cache Issues
      • Client Cache Issues
    • See Also
  • BaseLLMClient Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Position
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Basic Text Generation
        • Single Text Generation
        • Conversational Interaction
      • 4.2 Streaming Text Generation
        • Real-Time Streaming Output
        • Streaming Chat System
      • 4.3 Task Processing Integration
        • Task Description Generation
        • Code Generation and Optimization
      • 4.4 Content Analysis and Processing
        • Text Summarization
        • Sentiment Analysis
      • 4.5 Batch Processing
        • Batch Text Processing
    • 5. API Reference
      • 5.1 Data Class Definitions
        • LLMMessage
        • LLMResponse
      • 5.2 Exception Class Definitions
        • LLMClientError
        • ProviderNotAvailableError
        • RateLimitError
      • 5.3 Abstract Base Class
        • BaseLLMClient
      • 5.4 Abstract Methods
        • generate_text
        • stream_text
        • close
      • 5.5 Utility Methods
        • _count_tokens_estimate
        • _estimate_cost
    • 6. Technical Implementation Details
      • 6.1 Abstract Base Class Design
        • Interface Unification
      • 6.2 Data Class Design
        • Message Structure
        • Response Structure
      • 6.3 Error Handling Mechanism
        • Exception Hierarchy
        • Error Handling Strategy
      • 6.4 Cost Estimation Mechanism
        • Token Counting
        • Cost Calculation
      • 6.5 Context Management
        • Async Context Manager
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Environment Variable Configuration
        • Configuration File
      • 7.2 Concrete Implementation Examples
        • OpenAI Client Implementation
      • 7.3 Docker Deployment
        • Dockerfile Configuration
        • Docker Compose Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues and Solutions
        • Issue 1: Invalid API Key
        • Issue 2: Rate Limiting
        • Issue 3: Model Not Available
        • Issue 4: Network Connection Problems
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Request Flow Diagram
      • 9.3 Error Handling Flow Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Best Practices
      • D. Contact Information
  • LLM AI Clients Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 OpenAI Client
      • 4.2 Vertex AI Client
      • 4.3 xAI Client
    • 5. API Reference
      • 5.1 BaseLLMClient Abstract Base Class
        • Constructor
        • Abstract Methods
      • 5.2 OpenAIClient
        • Constructor
        • Features
        • Cost Estimation
      • 5.3 VertexAIClient
        • Constructor
        • Features
        • Safety Settings
      • 5.4 XAIClient
        • Constructor
        • Features
        • Model Mapping
    • 6. Technical Implementation Details
      • 6.1 Asynchronous Processing Mechanism
      • 6.2 Retry Mechanism
      • 6.3 Error Handling
      • 6.4 Cost Estimation
      • 6.5 Streaming Processing
    • 7. Configuration & Deployment
      • 7.1 Environment Variable Configuration
      • 7.2 Dependency Management
      • 7.3 Deployment Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues and Solutions
        • 8.2.1 API Key Issues
        • 8.2.2 Rate Limiting
        • 8.2.3 Content Filtering
      • 8.3 Performance Optimization
    • 9. Visualizations
      • 9.1 Architecture Flow Diagram
      • 9.2 Cost Analysis Diagram
      • 9.3 Performance Monitoring Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation
      • B. Example Code
      • C. Technical Support
  • LLM Custom Callback Handlers Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Basic Token Statistics Callback Handler
      • 4.2 Detailed Token Statistics Callback Handler
      • 4.3 Composite Callback Handler
    • 5. API Reference
      • 5.1 RedisTokenCallbackHandler
        • Constructor
        • Methods
      • 5.2 DetailedRedisTokenCallbackHandler
        • Constructor
        • Methods
      • 5.3 CompositeCallbackHandler
        • Constructor
        • Methods
      • 5.4 Convenience Functions
        • create_token_callback
        • create_detailed_token_callback
        • create_composite_callback
    • 6. Technical Implementation Details
      • 6.1 Asynchronous Processing Mechanism
      • 6.2 Token Estimation Algorithm
      • 6.3 Error Handling Strategy
      • 6.4 Performance Optimization
      • 6.5 Data Consistency
    • 7. Configuration & Deployment
      • 7.1 Environment Variable Configuration
      • 7.2 Dependency Management
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues and Solutions
        • 8.2.1 Redis Connection Failure
        • 8.2.2 Token Data Inconsistency
        • 8.2.3 Performance Issues
      • 8.3 Log Analysis
      • 8.4 Data Backup and Recovery
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Data Flow Diagram
      • 9.3 Token Usage Trend Chart
      • 9.4 Error Rate Monitoring Chart
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation Links
      • B. Example Code Repositories
      • C. Technical Support

Domain Modules

  • DOMAIN_COMMUNITY
    • Overview
    • Key Features
      • 🤝 Agent Community Management
      • 🏛️ Governance & Decision Making
      • 💬 Communication & Context Sharing
      • 🔧 Resource Management
      • 🔄 Collaborative Workflows
      • 🔌 Agent Integration
    • Architecture
    • Core Components
      • 1. CommunityManager
      • 2. DecisionEngine
      • 3. ResourceManager
      • 4. CommunicationHub
      • 5. SharedContextManager
      • 6. CollaborativeWorkflowEngine
      • 7. AgentAdapter System
      • 8. CommunityBuilder
    • Quick Start
    • Documentation Structure
    • Version
    • Requirements
    • Installation
    • Contributing
    • Important Notes
      • Enum Value Differences
      • Analytics Feature
    • License
  • DOMAIN_COMMUNITY Documentation Index
    • 📚 Complete Documentation Suite
    • 📖 Documentation Files
      • 1. README.md - Start Here! 📌
      • 2. API_REFERENCE.md - Complete API Reference 📋
      • 3. USAGE_GUIDE.md - Practical Tutorials 🎓
      • 4. ARCHITECTURE.md - System Design 🏗️
      • 5. EXAMPLES.md - Code Examples 💻
      • 6. ANALYTICS.md - Community Analytics ✅
      • 7. ADDENDUM.md - Accuracy Report ✅
      • 8. INDEX.md - This File 📇
    • 🎯 Quick Navigation by Use Case
      • “I’m new to DOMAIN_COMMUNITY”
      • “I need to implement a specific feature”
      • “I want to understand the architecture”
      • “I’m troubleshooting an issue”
      • “I need to verify documentation accuracy”
    • 🔍 Key Topics by Document
    • ⚠️ Important Information
      • Enum Value Changes
      • Future Features
    • 📊 Documentation Statistics
    • 🔄 Version Information
    • 🤝 Contributing to Documentation
    • 📞 Getting Help
    • 🎓 Learning Path
    • ✨ Quick Reference
      • Import Statement
      • Most Common Operations
  • Usage Guide
    • Table of Contents
    • Getting Started
      • Prerequisites
      • Basic Setup
    • Basic Community Operations
      • Creating a Community
        • Using CommunityBuilder (Recommended)
        • Direct Creation
      • Managing Members
      • Member Lifecycle Hooks
    • Decision Making
      • Proposing Decisions
      • Voting on Decisions
      • Advanced Decision Making
    • Resource Sharing
      • Creating and Sharing Resources
      • Model Sharing
    • Communication
      • Basic Messaging
      • Event Subscriptions
    • Collaborative Workflows
      • Creating Collaboration Sessions
      • Executing Workflow Steps
    • Advanced Features
      • Custom Agent Adapters
      • Shared Context Management
    • Best Practices
      • 1. Community Design
      • 2. Error Handling
      • 3. Resource Management
      • 4. Decision Making
    • Troubleshooting
      • Common Issues
        • 1. Community Not Found
        • 2. Permission Denied
        • 3. Decision Evaluation Fails
      • Debugging Tips
      • Performance Optimization
  • API Reference
    • Table of Contents
    • Core Managers
      • CommunityManager
        • Methods
      • DecisionEngine
        • Methods
      • ResourceManager
        • Methods
      • CollaborativeWorkflowEngine
      • CommunityAnalytics
        • Key Methods
        • CollaborativeWorkflowEngine Methods
    • Communication & Context
      • CommunicationHub
        • Methods
      • SharedContextManager
        • Methods
    • Agent Adapters
      • AgentAdapter
      • StandardLLMAdapter
      • AgentAdapterRegistry
    • Builder
      • CommunityBuilder
        • Usage Example
    • Models
      • AgentCommunity
      • CommunityMember
      • CommunityDecision
      • CommunityResource
      • CollaborationSession
    • Enums
      • CommunityRole
      • GovernanceType
      • DecisionStatus
      • ResourceType
      • ConsensusAlgorithm
      • MessageType
      • EventType
    • Exceptions
      • CommunityException
      • Specific Exceptions
    • Type Hints
    • Async/Await Support
  • Examples
    • Table of Contents
    • Basic Examples
      • Example 1: Creating a Research Community
      • Example 2: Adding Members and Managing Roles
      • Example 3: Decision Making Process
    • Advanced Use Cases
      • Example 4: Resource Sharing and Collaboration
      • Example 5: Collaborative Workflow Execution
    • Integration Examples
      • Example 6: Custom Agent Adapter
    • Real-World Scenarios
      • Example 7: Academic Research Collaboration
      • Example 8: Corporate Innovation Team
    • Performance Examples
      • Example 9: High-Performance Community Operations
    • Error Handling Examples
      • Example 10: Comprehensive Error Handling
  • Architecture
    • Table of Contents
    • System Overview
      • High-Level Architecture
    • Component Architecture
      • 1. CommunityManager
      • 2. DecisionEngine
      • 3. ResourceManager
      • 4. CommunicationHub
      • 5. SharedContextManager
      • 6. CollaborativeWorkflowEngine
      • 7. AgentAdapter System
    • Data Flow
      • 1. Community Creation Flow
      • 2. Decision Making Flow
      • 3. Resource Sharing Flow
      • 4. Communication Flow
    • Design Patterns
      • 1. Domain-Driven Design (DDD)
      • 2. Event-Driven Architecture
      • 3. CQRS (Command Query Responsibility Segregation)
      • 4. Repository Pattern
    • Integration Points
      • 1. External System Integration
      • 2. Infrastructure Layer Integration
      • 3. Domain Layer Integration
    • Scalability Considerations
      • 1. Horizontal Scaling
      • 2. Performance Optimization
      • 3. Resource Management
    • Security Architecture
      • 1. Authentication & Authorization
      • 2. Data Protection
      • 3. Audit & Compliance
    • Performance Characteristics
      • 1. Latency Characteristics
      • 2. Throughput Characteristics
      • 3. Scalability Limits
      • 4. Monitoring & Observability
  • Documentation Addendum
    • Documentation Accuracy Report
      • Last Updated
    • ✅ Accurate and Complete Coverage
      • Core Components (100% Documented)
    • ⚠️ Enum Value Corrections
      • CommunityRole
      • GovernanceType
      • DecisionStatus
      • ResourceType
    • ✅ CommunityAnalytics Now in Public API
      • CommunityAnalytics
    • 🔍 Model Attribute Differences
      • CommunityMember Model
    • 📁 Files Verified
      • Implementation Files Checked
      • Documentation Files Updated
    • 🎯 Completeness Assessment
      • Coverage by Category
    • 📝 Recommendations
      • For Documentation Maintainers
      • For Module Developers
    • ✨ Summary
  • Community Analytics
    • Overview
    • CommunityAnalytics Class
      • Initialization
      • Key Features
    • Methods
      • get_decision_analytics
      • get_participation_metrics
      • get_community_health_metrics
      • get_collaboration_effectiveness
      • get_member_analytics
      • get_trend_analysis
    • Analytics Metrics Reference
      • Health Score Components
      • Vitality Indicators
      • Engagement Score Calculation
    • Usage Examples
      • Complete Analytics Report
      • Real-time Monitoring
      • Member Performance Review
    • Import and Usage
    • Notes
  • Conversation Models Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. Domain Services
      • 2. Application Layer Services
      • 3. Infrastructure Layer
    • Downstream Components (Dependencies)
      • 1. Python Standard Library
      • 2. Domain Models
      • 3. Utility Functions
    • Core Model Details
      • 1. ConversationParticipant - Conversation Participant Model
      • 2. ConversationSession - Conversation Session Model
        • Session Key Generation
        • Participant Lookup
        • Activity Update
      • 3. AgentCommunicationMessage - Agent Communication Message Model
        • Convert to Conversation Message Format
    • Utility Functions Details
      • 1. create_session_key - Session Key Generation Utility
      • 2. validate_conversation_isolation_pattern - Session Isolation Validation Utility
    • Design Patterns Explained
      • 1. Dataclass Pattern
      • 2. Validation Pattern
      • 3. Factory Pattern
    • Usage Examples
      • 1. Basic Participant Management
      • 2. Conversation Session Management
      • 3. Agent Communication Messages
      • 4. Utility Function Usage
      • 5. Data Serialization and Deserialization
    • Maintenance Guide
      • 1. Daily Maintenance
        • Model Validation
        • Data Consistency Check
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Performance Optimization
        • Batch Operation Optimization
        • Memory Usage Optimization
      • 4. Data Migration
        • Model Version Upgrade
        • Data Format Conversion
    • Monitoring and Logging
      • Model Usage Monitoring
      • Logging
    • Version History
    • Related Documentation
  • ContextEngine Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. AI Service Layer
      • 2. Application Layer Services
      • 3. Workflow Engine
    • Downstream Components (Dependencies)
      • 1. Storage Interfaces
      • 2. Infrastructure Layer
      • 3. Domain Models
      • 4. Conversation Models
    • Core Functionality
      • 1. Session Management
        • Session Creation and Lifecycle
        • Session Updates and Metrics Tracking
      • 2. Conversation History Management
        • Conversation Message Storage
        • Conversation History Retrieval
      • 3. Task Context Management
        • Context Storage and Retrieval
      • 4. Checkpoint Management
        • LangGraph Checkpoint Integration
      • 5. Multi-Backend Storage Support
        • Storage Backend Automatic Switching
      • 6. Permanent Storage Dual-Write (Redis hot + cold archive)
        • Environment Configuration
        • PostgreSQL Tables (Auto-Created)
        • ClickHouse Tables (Auto-Created)
      • 7. Initialization via Infrastructure
    • Data Model Details
      • 1. SessionMetrics - Session Metrics Model
      • 2. ConversationMessage - Conversation Message Model
    • Design Patterns Explained
      • 1. Adapter Pattern
      • 2. Strategy Pattern
      • 3. Template Method Pattern
    • Usage Examples
      • 1. Basic Session Management
      • 2. Conversation History Management
      • 3. Task Context Management
      • 4. Checkpoint Management
      • 5. Advanced Conversation Session Management
    • Maintenance Guide
      • 1. Daily Maintenance
        • Health Checks
        • Performance Monitoring
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Performance Optimization
        • Memory Usage Optimization
        • Storage Performance Optimization
      • 4. Data Migration
        • Session Data Migration
    • Monitoring and Logging
      • Performance Monitoring
      • Logging
    • Version History
    • Integration Tests
    • Related Documentation
  • Execution Models Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. Application Layer Services
      • 2. Infrastructure Layer
      • 3. Interface Layer
    • Downstream Components (Dependencies)
      • 1. Python Standard Library
      • 2. Domain Models
      • 3. Utility Functions
    • Core Model Details
      • 1. TaskStatus - Task Status Enum
      • 2. ErrorCode - Error Code Enum
      • 3. TaskStepResult - Task Step Result Model
        • Serialization Method
        • String Representation
    • Design Patterns Explained
      • 1. Enum Pattern
      • 2. Value Object Pattern
      • 3. Factory Pattern
    • Usage Examples
      • 1. Basic State Management
      • 2. Result Model Usage
      • 3. System Integration
      • 4. Advanced Usage
    • Maintenance Guide
      • 1. Daily Maintenance
        • Model Validation
        • Data Consistency Check
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Performance Optimization
        • Object Creation Optimization
        • Memory Usage Optimization
      • 4. Data Migration
        • Model Version Upgrade
        • Data Format Conversion
    • Monitoring and Logging
      • Model Usage Monitoring
      • Logging
    • Version History
    • Related Documentation
  • Task Models Technical Documentation
    • 1. Overview
      • Core Functionality and Value
    • 2. Problem Background and Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning and Context
      • Component Type
      • Architecture Layers
      • Upstream Components (Consumers)
        • 1. Application Layer Services
        • 2. Domain Services
        • 3. Infrastructure Layer
      • Downstream Components (Dependencies)
        • 1. Python Standard Library
        • 2. Domain Models
        • 3. Utility Functions
    • 4. Core Features and Use Cases
      • 4.1 TaskContext - Task Context Management
        • Core Functionality
        • Software Functionality Scenarios
      • 4.2 DSLStep - DSL Step Definition
        • Core Functionality
        • Software Functionality Scenarios
      • 4.3 Real-World Use Cases
    • 5. API Reference
      • 5.1 TaskContext Class
        • Constructor
        • Methods
      • 5.2 DSLStep Class
        • Constructor
        • Methods
    • 6. Technical Implementation Details
      • 6.1 Data Model Design
        • TaskContext Design Principles
        • DSLStep Design Principles
      • 6.2 Serialization Mechanism
        • JSON Serialization Support
        • Deserialization Support
      • 6.3 Type Safety Mechanism
        • Type Annotations
        • Runtime Type Checking
    • 7. Configuration and Deployment
      • 7.1 Default Configuration
        • TaskContext Default Configuration
        • DSLStep Default Configuration
      • 7.2 Environment Variable Support
        • Configuration Environment Variables
        • Configuration Validation
      • 7.3 Deployment Configuration
        • Production Environment Configuration
        • Development Environment Configuration
    • 8. Maintenance and Troubleshooting
      • 8.1 Daily Maintenance
        • Model Health Check
        • Data Consistency Check
      • 8.2 Troubleshooting
        • Common Issue Diagnosis
      • 8.3 Performance Optimization
        • Memory Usage Optimization
        • Serialization Performance Optimization
    • 9. Visualizations
      • 9.1 Architecture Layers Diagram
      • 9.2 Data Flow Diagram
      • 9.3 Class Relationship Diagram
      • 9.4 Usage Scenario Flow Diagram
    • 10. Version History
      • v1.0.0 (2024-01-01)
      • v1.1.0 (2024-01-15)
      • v1.2.0 (2024-02-01)
      • v1.3.0 (2024-02-15)
      • v1.4.0 (2024-03-01)
      • v1.5.0 (2024-03-15)
    • Related Documentation
  • Task Context Technical Documentation
    • 1. Overview
      • Core Functionality and Value
    • 2. Problem Background and Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning and Context
      • Component Type
      • Architecture Layers
      • Upstream Components (Consumers)
        • 1. Application Layer Services
        • 2. Domain Services
        • 3. Infrastructure Layer
      • Downstream Components (Dependencies)
        • 1. Python Standard Library
        • 2. Domain Models
        • 3. Utility Functions
    • 4. Core Features and Use Cases
      • 4.1 TaskContext - Enhanced Task Context Management
        • Core Functionality
      • 4.2 ContextUpdate - Context Update Model
        • Core Functionality
      • 4.3 Software Functionality Scenarios
      • 4.4 Real-world Use Cases
    • 5. API Reference
      • 5.1 TaskContext Class
        • Constructor
        • Methods
      • 5.2 ContextUpdate Class
        • Constructor
      • 5.3 Utility Functions
        • build_context
        • task_context
    • 6. Technical Implementation Details
      • 6.1 Context History Management
        • Persistent Storage Mechanism
        • Async Save Mechanism
      • 6.2 Resource Management Mechanism
        • Resource Tracking and Cleanup
      • 6.3 Context Optimization Mechanism
        • Deduplication and Size Limiting
      • 6.4 Async Context Management
        • Async Context Manager Implementation
    • 7. Configuration and Deployment
      • 7.1 Default Configuration
        • TaskContext Default Configuration
      • 7.2 Environment Variable Support
        • Configuration Environment Variables
        • Configuration Validation
      • 7.3 Deployment Configuration
        • Production Environment Configuration
        • Development Environment Configuration
    • 8. Maintenance and Troubleshooting
      • 8.1 Daily Maintenance
        • Context Health Check
        • Performance Monitoring
      • 8.2 Troubleshooting
        • Common Issue Diagnosis
      • 8.3 Performance Optimization
        • Memory Usage Optimization
        • Context Optimization
    • 9. Visualizations
      • 9.1 Architecture Layers Diagram
      • 9.2 Context Lifecycle Diagram
      • 9.3 Resource Management Flow Diagram
      • 9.4 Async Context Management Diagram
    • 10. Version History
      • v1.0.0 (2024-01-01)
      • v1.1.0 (2024-01-15)
      • v1.2.0 (2024-02-01)
      • v1.3.0 (2024-02-15)
      • v1.4.0 (2024-03-01)
      • v1.5.0 (2024-03-15)
    • Related Documentation
  • DSL Processor Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. Application Layer Services
      • 2. Domain Services
      • 3. Infrastructure Layer
    • Downstream Components (Dependencies)
      • 1. Execution Models
      • 2. Python Standard Library
      • 3. Task Execution Functions
    • Core Functionality Details
      • 1. Condition Evaluation Engine
        • Supported Condition Types
        • Logical Operation Support
        • Condition Evaluation Method
      • 2. Step Type Support
        • IF Step - Conditional Branch
        • PARALLEL Step - Parallel Execution
        • SEQUENCE Step - Sequential Execution
        • TASK Step - Single Task Execution
        • LOOP Step - Loop Execution
      • 3. Value Parsing and Comparison
        • Value Parsing Method
        • Comparison Operation Support
      • 4. Async Execution Support
        • Main Execution Method
    • Design Patterns Explained
      • 1. Strategy Pattern
      • 2. Template Method Pattern
      • 3. Chain of Responsibility Pattern
    • Usage Examples
      • 1. Basic Condition Evaluation
      • 2. Complex Condition Evaluation
      • 3. DSL Step Execution
      • 4. Condition Syntax Validation
    • Maintenance Guide
      • 1. Daily Maintenance
        • Condition Pattern Validation
        • Step Type Validation
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Performance Optimization
        • Condition Evaluation Optimization
        • Memory Usage Optimization
      • 4. Extension Support
        • Adding New Condition Types
        • Adding New Step Types
    • Monitoring and Logging
      • Performance Monitoring
      • Logging
    • Version History
    • Related Documentation
  • Celery Task Worker Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Fast Task Processing
      • 4.2 Heavy Task Processing
      • 4.3 Real-time Progress Pushing
    • 5. API Reference
      • 5.1 Celery Application Configuration
        • celery_app
    • 6. Configuration & Deployment
      • 6.1 Environment Variable Configuration
      • 6.2 Dependency Management
      • 6.3 Deployment Configuration
      • 6.4 Monitoring Configuration
    • 7. Maintenance & Troubleshooting
      • 7.1 Monitoring Metrics
      • 7.2 Common Faults & Solutions
        • 7.2.1 Worker Process Crashes
        • 7.2.2 Task Execution Timeout
        • 7.2.3 WebSocket Connection Issues
      • 7.3 Performance Optimization
      • 7.4 Log Analysis
    • 8. Visualizations
      • 8.1 Task Execution Flow Diagram
      • 8.2 System Architecture Diagram
      • 8.3 Task State Transition Diagram
      • 8.4 Performance Monitoring Diagram
    • 9. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation
      • B. Example Code
      • C. Technical Support

Infrastructure

  • WebSocketManager Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 WebSocket Server Management
        • Starting and Stopping Server
        • Server Status Monitoring
      • 4.2 User Notification and Interaction
        • Task Step Result Notification
        • Error Handling and User Choice
      • 4.3 Real-Time Message Push
        • Broadcast Messages
        • User-Specific Messages
      • 4.4 Heartbeat Detection and Connection Management
        • Heartbeat Detection
        • Connection Status Monitoring
      • 4.5 Client Message Handling
        • Handling Client Confirmation
        • Handling Task Cancellation
    • 5. API Reference
      • 5.1 Class Definition
        • WebSocketManager
      • 5.2 Data Models
        • UserConfirmation
        • TaskStepResult
      • 5.3 Public Methods
        • start_server
        • stop_server
        • notify_user
        • broadcast_message
        • send_to_user
        • send_heartbeat
        • get_connection_count
        • get_status
    • 6. Technical Implementation Details
      • 6.1 Connection Management Mechanism
        • Connection Lifecycle Management
        • Connection Status Monitoring
      • 6.2 Message Handling Mechanism
        • Message Routing System
        • Callback Registration Mechanism
      • 6.3 Error Handling Strategy
        • Layered Error Handling
        • Connection Exception Handling
      • 6.4 Concurrency Control Mechanism
        • Asynchronous Message Broadcasting
        • Callback Timeout Control
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Server Configuration
        • Environment Variable Support
      • 7.2 Docker Deployment
        • Dockerfile Configuration
        • Docker Compose Configuration
      • 7.3 Load Balancing Configuration
        • Nginx Configuration
      • 7.4 Monitoring and Logging Configuration
        • Logging Configuration
        • Monitoring Metrics
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues & Solutions
        • Issue 1: Frequent Connection Drops
        • Issue 2: Message Loss
        • Issue 3: Memory Leak
        • Issue 4: High Concurrency Performance Issues
      • 8.3 Performance Optimization Recommendations
        • Connection Management Optimization
        • Message Processing Optimization
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 WebSocket Connection Flow Diagram
      • 9.3 Message Processing Flow Diagram
      • 9.4 Connection Management Architecture Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Client Examples
      • D. Contact Information
  • CeleryTaskManager Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Task Execution Functionality
        • Basic Task Execution
        • Heavy Task Execution
      • 4.2 DSL Task Step Execution
        • Complex Workflow Execution
      • 4.3 Batch Task Processing
        • Batch Execution of Multiple Tasks
      • 4.4 Task Monitoring and Management
        • Task Status Query
        • Queue Status Monitoring
    • 5. API Reference
      • 5.1 Class Definition
        • CeleryTaskManager
      • 5.2 Public Methods
        • execute_task
        • execute_heavy_task
        • execute_dsl_task_step
        • batch_execute_tasks
        • get_task_result
        • cancel_task
        • get_queue_info
        • get_worker_stats
    • 6. Technical Implementation Details
      • 6.1 Queue Management Strategy
        • Dual Queue Architecture
        • Worker Node Configuration
      • 6.2 Task Type Auto-Detection
      • 6.3 Timeout Handling Mechanism
        • Multi-Layer Timeout Control
      • 6.4 Error Handling Strategy
        • Exception Classification Handling
      • 6.5 Batch Processing Optimization
        • Batch Processing Strategy
    • 7. Configuration & Deployment
      • 7.1 Configuration Parameters
        • Required Configuration
        • Optional Configuration
      • 7.2 Environment Variable Support
      • 7.3 Docker Deployment
        • Docker Compose Configuration
      • 7.4 Production Environment Configuration
        • High Availability Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues & Solutions
        • Issue 1: Task Execution Timeout
        • Issue 2: Redis Connection Failure
        • Issue 3: Task Result Loss
        • Issue 4: Worker Node Memory Leak
      • 8.3 Performance Optimization Recommendations
        • Queue Optimization
        • Batch Processing Optimization
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Task Execution Flow Diagram
      • 9.3 Error Handling Flow Diagram
      • 9.4 Queue Management Architecture Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Contact Information
  • TracingManager Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Basic Tracing
        • Manual Span Creation
        • Automatic Tracing with Decorator
      • 4.2 Database Operation Tracing
        • Database Query Tracing
      • 4.3 External Service Call Tracing
        • HTTP Service Call Tracing
      • 4.4 Tool Execution Tracing
        • Tool Call Tracing
      • 4.5 Cross-Service Tracing
        • Context Propagation
    • 5. API Reference
      • 5.1 Class Definition
        • TracingManager
      • 5.2 Public Methods
        • start_span
        • finish_span
        • with_tracing
        • trace_database_operation
        • trace_external_call
        • trace_tool_execution
    • 6. Technical Implementation Details
      • 6.1 Jaeger Integration
        • Configuration Initialization
      • 6.2 Decorator Implementation
        • Async Function Support
      • 6.3 Context Propagation
        • Cross-Service Context Propagation
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Environment Variable Configuration
        • Code Configuration
      • 7.2 Docker Deployment
        • Docker Compose Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Common Issues & Solutions
        • Issue 1: Jaeger Connection Failure
        • Issue 2: Span Creation Failed
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Tracing Flow Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Contact Information
  • ExecutorMetrics Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Metrics Collection and Recording
        • Latency Metrics Recording
        • Success Rate Metrics Recording
      • 4.2 Decorator Monitoring
        • Automatic Monitoring with Decorator
      • 4.3 Comprehensive Operation Recording
        • Record Complete Operation Metrics
      • 4.4 Custom Metrics Recording
        • Business-Specific Metrics
      • 4.5 Metrics Query and Monitoring
        • Get Metrics Summary
        • Prometheus Metrics Query Examples
    • 5. API Reference
      • 5.1 Class Definition
        • ExecutorMetrics
      • 5.2 Public Methods
        • record_operation_latency
        • record_operation_success
        • record_operation_failure
        • record_retry
        • with_metrics
        • get_metrics_summary
        • record_operation
        • record_duration
    • 6. Technical Implementation Details
      • 6.1 Prometheus Metric Types
        • Histogram Metrics
        • Counter Metrics
      • 6.2 Decorator Implementation Mechanism
        • Async Function Monitoring
      • 6.3 Label Management Mechanism
        • Dynamic Label Support
        • Label Validation and Cleaning
      • 6.4 Error Handling Strategy
        • Metrics Recording Fault Tolerance
        • Metrics Initialization Fault Tolerance
      • 6.5 Performance Optimization Mechanism
        • Conditional Check Optimization
        • Batch Metrics Recording
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Metrics Collector Configuration
        • Environment Variable Support
      • 7.2 Docker Deployment
        • Dockerfile Configuration
        • Docker Compose Configuration
      • 7.3 Prometheus Configuration
        • prometheus.yml Configuration
      • 7.4 Grafana Dashboard Configuration
        • Dashboard JSON Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues & Solutions
        • Issue 1: Metrics Server Startup Failure
        • Issue 2: Metrics Recording Failed
        • Issue 3: Prometheus Unable to Scrape Metrics
        • Issue 4: Metrics Data Inaccurate
      • 8.3 Performance Optimization Recommendations
        • Metrics Recording Optimization
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Metrics Collection Flow Diagram
      • 9.3 Metric Types Architecture Diagram
      • 9.4 Monitoring Data Flow Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Monitoring Best Practices
      • D. Contact Information
  • Global Metrics Manager Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Dependencies
    • 4. Core Features & Characteristics
      • 4.1 Global Singleton Management
      • 4.2 Thread-Safe Initialization
      • 4.3 Convenient Access Interface
    • 5. Usage Guide
      • 5.1 Initialize at Application Startup
        • Initialize in main.py
      • 5.2 Usage in Components
        • Method 1: Directly Get Global Instance
        • Method 2: Use Convenience Functions
      • 5.3 Configuration Options
        • Environment Variable Configuration
        • Code Configuration
    • 6. Migration Guide
      • 6.1 Migrating from Independent ExecutorMetrics
        • Before Migration
        • After Migration
      • 6.2 Batch Migration Steps
    • 7. Best Practices
      • 7.1 Initialization Order
      • 7.2 Error Handling
      • 7.3 Performance Optimization
    • 8. Troubleshooting
      • 8.1 Common Issues
        • Issue 1: Metrics Not Initialized
        • Issue 2: Port Still in Use
        • Issue 3: Metrics Recording Failed
      • 8.2 Debugging Tips
        • Enable Verbose Logging
        • Check Metrics Endpoint
    • 9. Performance Considerations
      • 9.1 Memory Usage
      • 9.2 Network Overhead
      • 9.3 Startup Time
    • 10. Future Extensions
      • 10.1 Multi-Instance Support
      • 10.2 Dynamic Configuration
      • 10.3 Metrics Aggregation
    • Summary
  • DatabaseManager Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Database Connection Management
        • Connection Pool Initialization
        • Automatic Connection Management
      • 4.2 Task History Management
        • Save Task Execution History
        • Query Task History
      • 4.3 Task Status Management
        • Task Status Tracking
      • 4.4 Data Maintenance and Cleanup
        • Periodic Data Cleanup
      • 4.5 Batch Operations
        • Batch Save Task History
    • 5. API Reference
      • 5.1 Class Definition
        • DatabaseManager
      • 5.2 Public Methods
        • init_connection_pool
        • init_database_schema
        • save_task_history
        • load_task_history
        • mark_task_as_cancelled
        • check_task_status
        • get_user_tasks
        • cleanup_old_tasks
        • close
    • 6. Technical Implementation Details
      • 6.1 Connection Pool Management
        • Connection Pool Configuration
        • Connection Acquisition and Release
      • 6.2 Database Schema Management
        • Table Structure Creation
      • 6.3 Error Handling Strategy
        • Database Operation Fault Tolerance
        • Retry Mechanism
      • 6.4 Performance Optimization
        • Batch Operation Optimization
        • Query Optimization
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Database Configuration
        • Environment Variable Configuration
      • 7.2 Docker Deployment
        • Docker Compose Configuration
      • 7.3 Production Environment Configuration
        • High Availability Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues & Solutions
        • Issue 1: Connection Pool Exhausted
        • Issue 2: Database Connection Timeout
        • Issue 3: Data Consistency Issues
        • Issue 4: Database Performance Issues
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Database Operation Flow Diagram
      • 9.3 Connection Pool Management Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Best Practices
      • D. Contact Information
  • FileStorage Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Basic File Storage
        • Store Various Types of Data
        • Store Files with Metadata
      • 4.2 File Retrieval and Management
        • Retrieve Stored Files
        • Check File Existence
      • 4.3 File Listing and Search
        • List Stored Files
      • 4.4 File Deletion and Cleanup
        • Delete Files
        • Clean Expired Files
      • 4.5 Task Result Storage
        • Store Task Execution Results
      • 4.6 Caching and Performance Optimization
        • Leverage Cache to Improve Performance
    • 5. API Reference
      • 5.1 Class Definition
        • FileStorage
        • FileStorageConfig
      • 5.2 Public Methods
        • initialize
        • store
        • retrieve
        • delete
        • exists
        • list_keys
        • get_stats
      • 5.3 Global Functions
        • get_file_storage
        • initialize_file_storage
    • 6. Technical Implementation Details
      • 6.1 Storage Backend Management
        • Google Cloud Storage Integration
        • Local Storage Fallback
      • 6.2 Cache Management Mechanism
        • TTL Cache Implementation
        • Cache Size Management
      • 6.3 Data Serialization and Compression
        • Intelligent Serialization
        • Automatic Compression
      • 6.4 Error Handling and Retry Mechanism
        • Retry Decorator
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Complete Configuration Example
        • Environment Variable Configuration
      • 7.2 Docker Deployment
        • Dockerfile Configuration
        • Docker Compose Configuration
      • 7.3 Production Environment Configuration
        • High Availability Configuration
        • Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues & Solutions
        • Issue 1: Google Cloud Storage Connection Failure
        • Issue 2: Local Storage Space Insufficient
        • Issue 3: Cache Memory Leak
        • Issue 4: File Corruption or Data Inconsistency
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Storage Flow Diagram
      • 9.3 Cache Management Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Best Practices
      • D. Contact Information
  • RedisClient Technical Documentation
    • 1. Overview
      • Purpose
      • Core Value
    • 2. Problem Background & Design Motivation
      • Problem Background
      • Design Motivation
    • 3. Architecture Positioning & Context
      • System Architecture Location
      • Upstream Callers
      • Downstream Dependencies
    • 4. Core Features & Use Cases
      • 4.1 Basic Redis Operations
        • Key-Value Operations
        • Hash Table Operations
      • 4.2 Task Status Caching
        • Cache Task Execution Status
        • Task Result Caching
      • 4.3 User Session Management
        • Session Storage and Management
      • 4.4 Distributed Lock Implementation
        • Redis-Based Distributed Lock
      • 4.5 Cache Strategy Implementation
        • Multi-Level Cache Strategy
    • 5. API Reference
      • 5.1 Class Definition
        • RedisClient
      • 5.2 Public Methods
        • initialize
        • get_client
        • close
        • set
        • get
        • hset
        • hget
        • hgetall
        • hincrby
        • exists
        • expire
        • delete
        • ping
        • info
      • 5.3 Global Functions
        • initialize_redis_client
        • close_redis_client
        • get_redis_client
    • 6. Technical Implementation Details
      • 6.1 Connection Pool Management
        • Connection Pool Configuration
      • 6.2 Singleton Pattern Implementation
        • Global Instance Management
      • 6.3 Error Handling Strategy
        • Unified Error Handling
      • 6.4 Connection Health Check
        • Connection Status Monitoring
    • 7. Configuration & Deployment
      • 7.1 Basic Configuration
        • Environment Variable Configuration
        • Code Configuration
      • 7.2 Docker Deployment
        • Docker Compose Configuration
        • Dockerfile Configuration
      • 7.3 Production Environment Configuration
        • High Availability Configuration
        • Redis Cluster Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
        • Key Metrics
        • Monitoring Implementation
      • 8.2 Common Issues & Solutions
        • Issue 1: Connection Timeout
        • Issue 2: Out of Memory
        • Issue 3: Keyspace Notification Loss
        • Issue 4: Data Inconsistency
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Connection Management Flow Diagram
      • 9.3 Cache Strategy Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01)
    • Appendix
      • A. Related Documentation
      • B. External Dependencies
      • C. Best Practices
      • D. Contact Information

Core and Application

  • Storage Interfaces Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. Domain Services
      • 2. Application Layer Services
      • 3. Infrastructure Layer Implementations
    • Downstream Components (Dependencies)
      • 1. Python ABC System
      • 2. Domain Models
      • 3. Type System
    • Core Interfaces Explained
      • 1. ISessionStorage - Session Storage Interface
      • 2. IConversationStorage - Conversation Storage Interface
      • 3. ICheckpointStorage - Checkpoint Storage Interface
      • 4. ITaskContextStorage - Task Context Storage Interface
      • 5. IStorageBackend - Unified Storage Backend Interface
      • 6. ICheckpointerBackend - Checkpoint Backend Interface
    • Design Patterns Explained
      • 1. Interface Segregation Principle
      • 2. Dependency Inversion Principle
      • 3. Composition Pattern
    • Interface Implementation Standards
      • 1. Basic Implementation Requirements
        • Async Operation Support
        • Error Handling Standards
      • 2. Data Serialization Standards
        • Session Data Format
        • Conversation Message Format
      • 3. Performance Optimization Standards
        • Batch Operation Support
        • Caching Strategy
    • Usage Examples
      • 1. Basic Storage Implementation
        • Redis Storage Implementation
        • PostgreSQL Storage Implementation
      • 2. Storage Factory Pattern
      • 3. Storage Adapter Pattern
    • Maintenance Guide
      • 1. Daily Maintenance
        • Storage Health Check
        • Data Migration Tool
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Performance Optimization
        • Connection Pool Management
        • Batch Operation Optimization
    • Monitoring and Logging
      • Storage Monitoring Metrics
      • Storage Logging
    • Version History
    • Related Documentation
  • Execution Interfaces Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. Application Layer Executors
      • 2. Infrastructure Layer Implementations
      • 3. Domain Services
    • Downstream Components (Dependencies)
      • 1. Python ABC System
      • 2. Domain Models
      • 3. Type System
    • Core Interfaces Explained
      • 1. IToolProvider - Tool Provider Interface
      • 2. IToolExecutor - Tool Executor Interface
      • 3. ICacheProvider - Cache Provider Interface
      • 4. IOperationExecutor - Operation Executor Interface
      • 5. ExecutionInterface - Unified Execution Interface
    • Design Patterns Explained
      • 1. Interface Segregation Principle
      • 2. Dependency Inversion Principle
      • 3. Strategy Pattern
    • Interface Implementation Standards
      • 1. Interface Implementation Requirements
        • Required Methods
        • Type Safety Requirements
      • 2. Error Handling Standards
        • Exception Type Definitions
        • Error Handling Implementation
      • 3. Logging and Monitoring Standards
        • Logging
        • Performance Monitoring
    • Usage Examples
      • 1. Basic Interface Implementation
        • Tool Provider Implementation
        • Tool Executor Implementation
      • 2. Cache Provider Implementation
      • 3. Operation Executor Implementation
    • Maintenance Guide
      • 1. Daily Maintenance
        • Interface Compatibility Check
        • Interface Version Management
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Interface Updates
        • Adding New Methods
        • Interface Version Control
      • 4. Interface Extension
        • Support Generic Interfaces
        • Support Async Context Management
    • Performance Optimization
      • 1. Interface Method Caching
      • 2. Async Interface Optimization
      • 3. Interface Performance Monitoring
    • Monitoring and Logging
      • Interface Usage Monitoring
    • Version History
    • Related Documentation
  • Service Registry Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. Task Executor (tasks/worker.py)
      • 2. FastAPI Application (main.py)
      • 3. Service Manager (infrastructure/messaging/celery_task_manager.py)
    • Downstream Components (Dependencies)
      • 1. Python Decorator System
      • 2. Service Implementation Classes
      • 3. Type System
    • Core Features
      • 1. Service Registration Mechanism
      • 2. Service Discovery Mechanism
      • 3. Service Registry Management
    • Design Patterns Explained
      • 1. Decorator Pattern
      • 2. Registry Pattern
      • 3. Factory Pattern
    • Service Registration Standards
      • 1. Service Naming Conventions
      • 2. Service Interface Standards
      • 3. Service Metadata Standards
    • Usage Examples
      • 1. Basic Service Registration
      • 2. Service Discovery and Usage
      • 3. Service List Query
      • 4. Service Factory Pattern
    • Maintenance Guide
      • 1. Daily Maintenance
        • Service Registry Health Check
        • Service Registry Monitoring
      • 2. Troubleshooting
        • Common Issue Diagnosis
      • 3. Configuration Updates
        • Adding New Service Types
        • Service Version Management
      • 4. Configuration Extension
        • Support Service Configuration
        • Support Service Lifecycle Management
    • Performance Optimization
      • 1. Service Caching
      • 2. Lazy Loading
      • 3. Service Warmup
    • Monitoring and Logging
      • Service Registry Monitoring
    • Version History
    • Related Documentation
  • Configuration Management System Technical Documentation
    • Overview
      • Design Motivation and Problem Background
      • Component Positioning
    • Component Type and Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Consumers)
      • 1. AIECS Client (aiecs_client.py)
      • 2. FastAPI Application (main.py)
      • 3. Infrastructure Components
      • 4. LLM Clients
      • 5. Task Executor (tasks/worker.py)
    • Downstream Components (Dependencies)
      • 1. Pydantic Settings (pydantic_settings.BaseSettings)
      • 2. Environment Variable System
      • 3. External Service Configurations
    • Core Features
      • 1. Configuration Definition and Validation
      • 2. Layered Configuration Validation
      • 3. Configuration Combinators
      • 4. Singleton Pattern Configuration Access
    • Configuration Parameters Details
      • LLM Provider Configuration
        • OpenAI Configuration
        • Vertex AI Configuration
        • xAI Configuration
      • Infrastructure Configuration
        • Database Configuration
        • Message Queue Configuration
        • CORS Configuration
      • Cloud Service Configuration
        • Google Cloud Storage
        • Vector Database Configuration
    • Configuration Management Best Practices
      • 1. Environment Variable Management
        • Development Environment Configuration
        • Production Environment Configuration
      • 2. Configuration Validation Strategy
        • Startup Validation
        • Functional Module Validation
      • 3. Configuration Security
        • Sensitive Information Protection
        • Configuration Encryption
      • 4. Configuration Monitoring
        • Configuration Change Logging
    • Maintenance Guide
      • 1. Daily Maintenance
        • Configuration Health Check
        • Configuration Backup
      • 2. Troubleshooting
        • Common Configuration Issues
      • 3. Configuration Updates
        • Adding New Configuration Parameters
        • Update Configuration Validation
        • Configuration Migration
      • 4. Configuration Extension
        • Support New Configuration Sources
        • Support Configuration Hot Updates
    • Performance Optimization
      • 1. Configuration Caching
      • 2. Lazy Loading
      • 3. Configuration Pre-validation
    • Monitoring and Logging
      • Configuration Monitoring Metrics
      • Configuration Change Logging
    • Version History
    • Related Documentation
  • OperationExecutor Component Technical Documentation
    • Overview
      • Design Motivation & Problem Background
      • Component Positioning
    • Component Type & Positioning
      • Component Type
      • Architecture Layers
    • Upstream Components (Callers)
      • 1. AIECS Client (aiecs_client.py)
      • 2. FastAPI Application (main.py)
      • 3. WebSocket Service (socket_server.py)
      • 4. Celery Task Manager (infrastructure/messaging/celery_task_manager.py)
      • 5. Task Executor (tasks/worker.py)
    • Downstream Components (Dependencies)
      • 1. ToolExecutor (tools/tool_executor/tool_executor.py)
      • 2. ExecutionUtils (utils/execution_utils.py)
      • 3. Tool Registry (tools/__init__.py)
      • 4. Domain Models (domain/execution/model.py)
    • Key Domain Models
      • TaskStepResult
      • TaskStatus
      • ErrorCode
    • Core Features
      • 1. Single Operation Execution
        • Parameters Dictionary Contract
      • 2. Batch Operation Execution
      • 3. Sequential Operation Execution
      • 4. Parallel Operation Execution
      • 5. Tool Call Batch Processing
    • Technical Features
      • 1. Parameter Processing
      • 2. Caching Mechanism
      • 3. Concurrency Control
      • 4. Error Handling
      • 5. Tool Management
    • API Interface
      • Constructor
      • Main Methods
        • 1. execute_operation
        • 2. batch_execute_operations
        • 3. execute_operations_sequence
        • 4. execute_parallel_operations
        • 5. batch_tool_calls
      • Utility Methods
        • 1. get_tool_instance
        • 2. clear_tool_cache
        • 3. get_stats
    • Configuration Management
      • Default Configuration
      • Environment Variable Support
    • Error Handling
      • Exception Types & Examples
        • 1. ValueError - Parameter Validation Error
        • 2. AttributeError - Tool or Operation Not Found
        • 3. Exception - General Execution Error
      • Error Code Mapping
      • Error Recovery Strategies
        • 1. Single Operation Error Handling
        • 2. Sequence Operation Error Handling
        • 3. Parallel Operation Error Handling
      • Error Monitoring and Debugging
    • Performance Optimization
      • 1. Caching Strategy
      • 2. Concurrency Control
      • 3. Resource Management
    • Monitoring & Logging
      • Logging
      • Statistics
    • Maintenance Guide
      • 1. Daily Maintenance
      • 2. Troubleshooting
      • 3. Extension Development
      • 4. Configuration Tuning
    • Dependency Diagram
      • Component Architecture Diagram
      • Data Flow Diagram
      • Calling Scenario Flow Diagram
      • Concurrency Control Diagram
    • Software Function Scenarios
      • 1. Data Analysis & Processing Pipeline
      • 2. Document Processing & Content Extraction
      • 3. Real-time Data Processing & Monitoring
      • 4. Intelligent Content Generation & Optimization
      • 5. Batch File Processing & Conversion
      • 6. Multimodal Data Processing
      • 7. Workflow Automation & Orchestration
      • 8. Real-time Collaboration & Sharing
    • Real-world Use Cases
      • Case 1: E-commerce Data Analysis Platform
      • Case 2: Intelligent Document Processing System
      • Case 3: Real-time Monitoring & Alerting System
    • Usage Examples
      • Basic Usage
      • Advanced Usage
    • Version History
    • Related Documentation
  • LLM Output Structor Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Intelligent Term Replacement
      • 4.2 Structured Format Optimization
      • 4.3 Humanized Interaction Enhancement
      • 4.4 Multi-Scenario Message Optimization
    • 5. API Reference
      • 5.1 LLMOutputTransformer Class
        • Constructor
        • Methods
      • 5.2 Convenience Functions
        • format_clarification_message
        • format_confirmation_message
        • enhance_reasoning
        • clean_technical_terms
    • 6. Technical Implementation Details
      • 6.1 Term Replacement Mechanism
      • 6.2 Conversational Conversion Mechanism
      • 6.3 Format Optimization Mechanism
      • 6.4 Scenario-Based Processing Mechanism
      • 6.5 Performance Optimization Strategies
    • 7. Configuration & Deployment
      • 7.1 Environment Requirements
      • 7.2 Configuration Options
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues & Solutions
        • 8.2.1 Inaccurate Term Replacement
        • 8.2.2 Format Conversion Errors
        • 8.2.3 Performance Issues
      • 8.3 Log Analysis
      • 8.4 Testing and Validation
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Data Flow Diagram
      • 9.3 Term Replacement Effect Chart
      • 9.4 Message Type Distribution Chart
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation Links
      • B. Example Code Repositories
      • C. Technical Support
      • D. Best Practices
        • D.1 Term Mapping Best Practices
        • D.2 Format Template Best Practices
        • D.3 Performance Optimization Best Practices
  • Prompt Loader Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Dynamic Prompt Loading
      • 4.2 Multi-Mode Configuration Support
      • 4.3 Service Isolation Management
      • 4.4 Fault Tolerance and Default Handling
    • 5. API Reference
      • 5.1 get_prompt Function
        • Function Definition
        • Internal Implementation Logic
    • 6. Technical Implementation Details
      • 6.1 File Path Resolution Mechanism
      • 6.2 YAML Parsing Mechanism
      • 6.3 Error Handling Mechanism
      • 6.4 Performance Optimization Strategies
      • 6.5 Configuration Validation Mechanism
    • 7. Configuration & Deployment
      • 7.1 Environment Requirements
      • 7.2 Configuration File Structure
      • 7.3 Environment Variable Configuration
      • 7.4 Deployment Configuration
      • 7.5 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues & Solutions
        • 8.2.1 Configuration File Not Found
        • 8.2.2 YAML Parsing Error
        • 8.2.3 Service Prompt Not Found
      • 8.3 Performance Optimization
      • 8.4 Log Analysis
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Data Flow Diagram
      • 9.3 Usage Pattern Distribution Chart
      • 9.4 Service Usage Distribution Chart
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation Links
      • B. Example Code Repositories
      • C. Technical Support
      • D. Best Practices
        • D.1 Prompt Design Best Practices
        • D.2 Configuration Management Best Practices
        • D.3 Performance Optimization Best Practices
  • Token Usage Repository Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Precise Token Statistics
      • 4.2 Usage Limit Management
      • 4.3 Usage Query and Statistics
      • 4.4 Data Reset and Management
    • 5. API Reference
      • 5.1 TokenUsageRepository Class
        • Constructor
        • Methods
      • 5.2 Global Instance
        • token_usage_repo
    • 6. Technical Implementation Details
      • 6.1 Redis Key Design
      • 6.2 Atomic Operation Mechanism
      • 6.3 Error Handling Mechanism
      • 6.4 Performance Optimization Strategies
      • 6.5 Data Consistency Guarantees
    • 7. Configuration & Deployment
      • 7.1 Environment Requirements
      • 7.2 Environment Variable Configuration
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues & Solutions
        • 8.2.1 Redis Connection Failure
        • 8.2.2 Data Inconsistency
        • 8.2.3 Performance Issues
      • 8.3 Data Backup and Recovery
      • 8.4 Log Analysis
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Data Flow Diagram
      • 9.3 Token Usage Trend Chart
      • 9.4 User Usage Distribution Chart
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation Links
      • B. Example Code Repositories
      • C. Technical Support
      • D. Best Practices
        • D.1 Usage Statistics Best Practices
        • D.2 Usage Limit Best Practices
        • D.3 Monitoring and Alerting Best Practices
  • Execution Utils Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Intelligent Cache Management
      • 4.2 Robust Retry Mechanism
      • 4.3 Precise Timeout Control
      • 4.4 Context-Aware Caching
    • 5. API Reference
      • 5.1 ExecutionUtils Class
        • Constructor
        • Methods
    • 6. Technical Implementation Details
      • 6.1 Cache Implementation Mechanism
      • 6.2 Retry Strategy Implementation
      • 6.3 Timeout Control Implementation
      • 6.4 Cache Key Generation Algorithm
      • 6.5 Performance Optimization Strategies
    • 7. Configuration & Deployment
      • 7.1 Environment Requirements
      • 7.2 Configuration Options
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues & Solutions
        • 8.2.1 Cache Memory Leak
        • 8.2.2 Retry Storm
        • 8.2.3 Improper Timeout Configuration
      • 8.3 Performance Tuning
      • 8.4 Log Analysis
    • 9. Visualizations
      • 9.1 System Architecture Diagram
      • 9.2 Data Flow Diagram
      • 9.3 Cache Hit Rate Trend Chart
      • 9.4 Operation Execution Time Distribution Chart
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation Links
      • B. Example Code Repositories
      • C. Technical Support
      • D. Best Practices
        • D.1 Cache Strategy Best Practices
        • D.2 Retry Strategy Best Practices
        • D.3 Monitoring and Alerting Best Practices
  • Base Callback Handler Technical Documentation
    • 1. Overview
    • 2. Problem Background & Design Motivation
      • 2.1 Business Pain Points
      • 2.2 Design Motivation
    • 3. Architecture Positioning & Context
      • 3.1 System Architecture Diagram
      • 3.2 Upstream and Downstream Dependencies
      • 3.3 Data Flow
    • 4. Core Features & Use Cases
      • 4.1 Abstract Callback Interface Definition
      • 4.2 Lifecycle Management
      • 4.3 Type Safety Design
    • 5. API Reference
      • 5.1 CustomAsyncCallbackHandler
        • Class Definition
        • Abstract Methods
    • 6. Technical Implementation Details
      • 6.1 Abstract Base Class Design Pattern
      • 6.2 Asynchronous Programming Support
      • 6.3 Type Safety Design
      • 6.4 Error Handling Mechanism
      • 6.5 Performance Optimization
    • 7. Configuration & Deployment
      • 7.1 Environment Requirements
      • 7.2 Configuration Options
      • 7.3 Deployment Configuration
      • 7.4 Monitoring Configuration
    • 8. Maintenance & Troubleshooting
      • 8.1 Monitoring Metrics
      • 8.2 Common Issues & Solutions
        • 8.2.1 Callback Execution Timeout
        • 8.2.2 Memory Leak
        • 8.2.3 Concurrency Issues
      • 8.3 Log Analysis
      • 8.4 Performance Tuning
    • 9. Visualizations
      • 9.1 Class Inheritance Diagram
      • 9.2 Data Flow Diagram
      • 9.3 System Architecture Diagram
      • 9.4 Performance Monitoring Diagram
    • 10. Version History
      • v1.0.0 (2024-01-15)
      • v1.1.0 (2024-02-01)
      • v1.2.0 (2024-03-01)
      • v1.3.0 (2024-04-01) [Planned]
    • Appendix
      • A. Related Documentation Links
      • B. Example Code Repositories
      • C. Technical Support
      • D. Best Practices
        • D.1 Implementing Custom Callback Handlers
        • D.2 Error Handling Best Practices
        • D.3 Performance Optimization Best Practices

API Reference

  • Core API
    • Core Interfaces
      • IToolProvider
        • IToolProvider.get_tool()
        • IToolProvider.has_tool()
      • IToolExecutor
        • IToolExecutor.execute()
        • IToolExecutor.execute_async()
      • ICacheProvider
        • ICacheProvider.generate_cache_key()
        • ICacheProvider.get_from_cache()
        • ICacheProvider.add_to_cache()
      • IOperationExecutor
        • IOperationExecutor.execute_operation()
        • IOperationExecutor.batch_execute_operations()
        • IOperationExecutor.execute_operations_sequence()
        • IOperationExecutor.execute_parallel_operations()
      • ExecutionInterface
        • ExecutionInterface.execute_operation()
        • ExecutionInterface.execute_task()
        • ExecutionInterface.batch_execute_operations()
        • ExecutionInterface.batch_execute_tasks()
        • ExecutionInterface.register_executor()
      • ISessionStorage
        • ISessionStorage.create_session()
        • ISessionStorage.get_session()
        • ISessionStorage.update_session()
        • ISessionStorage.end_session()
      • IConversationStorage
        • IConversationStorage.add_conversation_message()
        • IConversationStorage.get_conversation_history()
      • ICheckpointStorage
        • ICheckpointStorage.store_checkpoint()
        • ICheckpointStorage.get_checkpoint()
        • ICheckpointStorage.list_checkpoints()
      • ITaskContextStorage
        • ITaskContextStorage.get_task_context()
        • ITaskContextStorage.store_task_context()
      • IStorageBackend
        • IStorageBackend.initialize()
        • IStorageBackend.close()
        • IStorageBackend.health_check()
        • IStorageBackend.get_metrics()
        • IStorageBackend.cleanup_expired_sessions()
      • IPermanentStorageBackend
        • IPermanentStorageBackend.append_session_event()
        • IPermanentStorageBackend.append_conversation_message()
        • IPermanentStorageBackend.append_checkpoint()
        • IPermanentStorageBackend.append_checkpoint_writes()
        • IPermanentStorageBackend.append_conversation_session()
        • IPermanentStorageBackend.append_task_context_snapshot()
        • IPermanentStorageBackend.initialize()
        • IPermanentStorageBackend.close()
      • ICheckpointerBackend
        • ICheckpointerBackend.put_checkpoint()
        • ICheckpointerBackend.get_checkpoint()
        • ICheckpointerBackend.list_checkpoints()
        • ICheckpointerBackend.put_writes()
        • ICheckpointerBackend.get_writes()
  • Domain API
    • Agent
      • Base Agent
        • OperationTimer
        • CacheConfig
        • BaseAIAgent
    • Context
      • Context Engine
        • DateTimeEncoder
        • SessionMetrics
        • ConversationMessage
        • CompressionConfig
        • ContextEngine
    • Task
      • Task Context
        • ContextUpdate
        • TaskContext
        • build_context()
        • task_context()
      • Task Models
        • TaskContext
        • DSLStep
  • Application API
    • Application Executors
      • OperationExecutor
        • OperationExecutor.__init__()
        • OperationExecutor.execute_operation()
        • OperationExecutor.batch_execute_operations()
        • OperationExecutor.execute_operations_sequence()
        • OperationExecutor.batch_tool_calls()
        • OperationExecutor.extract_tool_calls()
        • OperationExecutor.execute_parallel_operations()
        • OperationExecutor.get_tool_instance()
        • OperationExecutor.clear_tool_cache()
        • OperationExecutor.get_stats()
    • Knowledge Graph
  • Infrastructure API
    • Persistence
      • Database Manager
        • DatabaseManager
      • File Storage
        • FileStorageError
        • FileStorageConfig
        • FileStorage
        • get_file_storage()
        • initialize_file_storage()
      • Redis Client
        • RedisClient
        • initialize_redis_client()
        • close_redis_client()
        • get_redis_client()
    • Monitoring
      • Executor Metrics
        • ExecutorMetrics
      • Global Metrics Manager
        • initialize_global_metrics()
        • get_global_metrics()
        • close_global_metrics()
        • is_metrics_initialized()
        • get_metrics_summary()
        • record_operation()
        • record_duration()
        • record_operation_success()
        • record_operation_failure()
        • record_retry()
      • Tracing Manager
        • TracingManager
    • Messaging
      • Celery Task Manager
        • CeleryTaskManager
      • WebSocket Manager
        • UserConfirmation
        • TaskStepResult
        • WebSocketManager
  • Tools API
    • Tool Configuration
      • Tool Config Loader
        • ToolConfigLoader
        • get_tool_config_loader()
    • Base Tool
      • BaseTool
        • BaseTool.__init__()
        • BaseTool.settings
        • BaseTool.get_schema_coverage()
        • BaseTool.run()
        • BaseTool.run_async()
        • BaseTool.run_batch()
    • Document Tools
      • Document Parser
        • DocumentType
        • ParsingStrategy
        • OutputFormat
        • DocumentParserError
        • UnsupportedDocumentError
        • DownloadError
        • ParseError
        • DocumentParserTool
        • DocumentParserSettings
      • Document Creator
        • DocumentType
        • DocumentFormat
        • TemplateType
        • StylePreset
        • DocumentCreatorError
        • TemplateError
        • DocumentCreationError
        • DocumentCreatorTool
        • DocumentCreatorSettings
      • Document Writer
        • DocumentFormat
        • WriteMode
        • EditOperation
        • EncodingType
        • ValidationLevel
        • DocumentWriterError
        • WriteError
        • ValidationError
        • SecurityError
        • WritePermissionError
        • ContentValidationError
        • StorageError
        • DocumentWriterTool
        • DocumentWriterSettings
    • Search Tool
      • SearchTool
        • SearchTool.Config
        • SearchTool.Search_webSchema
        • SearchTool.Search_imagesSchema
        • SearchTool.Search_newsSchema
        • SearchTool.Search_videosSchema
        • SearchTool.Get_metricsSchema
        • SearchTool.Get_metrics_reportSchema
        • SearchTool.Get_health_scoreSchema
        • SearchTool.Get_quota_statusSchema
        • SearchTool.Get_search_contextSchema
        • SearchTool.description
        • SearchTool.category
        • SearchTool.__init__()
        • SearchTool.search_web()
        • SearchTool.search_images()
        • SearchTool.search_news()
        • SearchTool.search_videos()
        • SearchTool.get_metrics()
        • SearchTool.get_metrics_report()
        • SearchTool.get_health_score()
        • SearchTool.get_quota_status()
        • SearchTool.get_search_context()
      • SearchType
        • SearchType.WEB
        • SearchType.IMAGE
        • SearchType.NEWS
        • SearchType.VIDEO
        • SearchType.__new__()
      • SafeSearch
        • SafeSearch.OFF
        • SafeSearch.MEDIUM
        • SafeSearch.HIGH
        • SafeSearch.__new__()
      • ImageSize
        • ImageSize.ICON
        • ImageSize.SMALL
        • ImageSize.MEDIUM
        • ImageSize.LARGE
        • ImageSize.XLARGE
        • ImageSize.XXLARGE
        • ImageSize.HUGE
        • ImageSize.__new__()
      • ImageType
        • ImageType.CLIPART
        • ImageType.FACE
        • ImageType.LINEART
        • ImageType.STOCK
        • ImageType.PHOTO
        • ImageType.ANIMATED
        • ImageType.__new__()
      • ImageColorType
        • ImageColorType.COLOR
        • ImageColorType.GRAY
        • ImageColorType.MONO
        • ImageColorType.TRANS
        • ImageColorType.__new__()
      • QueryIntentType
        • QueryIntentType.DEFINITION
        • QueryIntentType.HOW_TO
        • QueryIntentType.COMPARISON
        • QueryIntentType.FACTUAL
        • QueryIntentType.RECENT_NEWS
        • QueryIntentType.ACADEMIC
        • QueryIntentType.PRODUCT
        • QueryIntentType.GENERAL
        • QueryIntentType.__new__()
      • CredibilityLevel
        • CredibilityLevel.HIGH
        • CredibilityLevel.MEDIUM
        • CredibilityLevel.LOW
        • CredibilityLevel.__new__()
      • CircuitState
        • CircuitState.CLOSED
        • CircuitState.OPEN
        • CircuitState.HALF_OPEN
        • CircuitState.__new__()
      • SearchToolError
      • AuthenticationError
      • QuotaExceededError
      • RateLimitError
      • CircuitBreakerOpenError
      • SearchAPIError
      • ValidationError
      • CacheError
    • API Source Tool
      • API Source Tool
  • LLM API
    • Client Factory
      • AIProvider
        • AIProvider.OPENAI
        • AIProvider.VERTEX
        • AIProvider.GOOGLEAI
        • AIProvider.XAI
        • AIProvider.OPENROUTER
        • AIProvider.ANTHROPIC_VERTEX
        • AIProvider.VERTEX_MAAS
        • AIProvider.__new__()
      • LLMClientFactory
        • LLMClientFactory.register_custom_provider()
        • LLMClientFactory.get_client()
        • LLMClientFactory.close_all()
        • LLMClientFactory.close_client()
        • LLMClientFactory.reload_config()
      • LLMClientManager
        • LLMClientManager.__init__()
        • LLMClientManager.generate_text()
        • LLMClientManager.stream_text()
        • LLMClientManager.close()
      • get_llm_manager()
      • generate_text()
      • stream_text()
    • LLM Clients
      • OpenAI Client
        • OpenAIClient
      • Vertex AI Client
        • VertexAIClient
      • xAI Client
        • XAIClient
    • Configuration
      • Model Config
        • ModelCostConfig
        • ModelCapabilities
        • ModelDefaultParams
        • ModelConfig
        • ProviderConfig
        • LLMModelsConfig
      • Config Loader
        • LLMConfigLoader
        • get_llm_config_loader()
        • get_llm_config()
        • reload_llm_config()

Development

  • Changelog
    • [Unreleased]
      • Changed
      • Planned (v3)
      • Added (Phase 3+ extensions)
    • [1.5.3] - 2024-01-XX
      • Added
      • Changed
      • Fixed
    • [1.5.2] - 2024-01-XX
      • Added
      • Changed
    • [1.5.1] - 2024-01-XX
      • Added
      • Changed
      • Fixed
    • [1.5.0] - 2024-01-XX
      • Added
      • Changed
    • [1.0.0] - 2023-XX-XX
      • Added
AIECS
  • Python Module Index

Python Module Index

a
 
a
- aiecs
    aiecs.application.executors
    aiecs.config.tool_config
    aiecs.core.interface.execution_interface
    aiecs.core.interface.storage_interface
    aiecs.domain.agent.base_agent
    aiecs.domain.context.context_engine
    aiecs.domain.task.model
    aiecs.domain.task.task_context
    aiecs.infrastructure.messaging.celery_task_manager
    aiecs.infrastructure.messaging.websocket_manager
    aiecs.infrastructure.monitoring.executor_metrics
    aiecs.infrastructure.monitoring.global_metrics_manager
    aiecs.infrastructure.monitoring.tracing_manager
    aiecs.infrastructure.persistence.database_manager
    aiecs.infrastructure.persistence.file_storage
    aiecs.infrastructure.persistence.redis_client
    aiecs.llm.client_factory
    aiecs.llm.clients.openai_client
    aiecs.llm.clients.vertex_client
    aiecs.llm.clients.xai_client
    aiecs.llm.config.config_loader
    aiecs.llm.config.model_config
    aiecs.tools.base_tool
    aiecs.tools.docs.document_creator_tool
    aiecs.tools.docs.document_parser_tool
    aiecs.tools.docs.document_writer_tool
    aiecs.tools.search_tool

© Copyright 2026, AIECS Team.

Built with Sphinx using a theme provided by Read the Docs.