AIECS - AI Execute Services

Welcome to AIECS (AI Execute Services), a powerful Python middleware framework for building AI-powered applications with tool orchestration, task execution, and multi-provider LLM support.

Features

• Multi-Provider LLM Support: Seamlessly integrate with OpenAI, Google Vertex AI, and xAI

• Tool Orchestration: Extensible tool system for various tasks (web scraping, data analysis, document processing, etc.)

• Asynchronous Task Execution: Built on Celery for scalable task processing

• Real-time Communication: WebSocket support for live updates and progress tracking

• Enterprise-Ready: Production-grade architecture with PostgreSQL, Redis, and Google Cloud Storage integration

• Extensible Architecture: Easy to add custom tools and AI providers

Quick Start

Installation

Install AIECS from PyPI:

pip install aiecs

Or install with documentation dependencies:

pip install aiecs[docs]

Basic Usage

from aiecs import AIECSClient

# Initialize the client
client = AIECSClient()

# Execute a task
result = await client.execute_task(
    task_type="text_generation",
    parameters={"prompt": "Hello, world!"}
)

Documentation Contents

Getting Started

• Installation
  • Requirements
  • Basic Installation
  • Optional Dependencies
  • Post-Installation Setup
  • Configuration
  • Verification
  • Troubleshooting
• Quick Start Guide
  • Prerequisites
  • Basic Usage
  • Working with Tools
  • Using LLM Providers
  • Task Execution with Celery
  • WebSocket Communication
  • Next Steps
• Configuration
  • Environment Variables
  • Tool Configuration
  • Configuration File
  • Programmatic Configuration
  • Best Practices
  • See Also
• Advanced Usage
  • Agent System
  • Tool Integration
  • Context Management
  • Task Orchestration
  • Error Handling
  • Monitoring and Observability
  • Performance Optimization
  • Best Practices
  • See Also
• AIECS Usage Guide
  • 🔧 Three Usage Modes Explained
  • 🔄 Usage Mode Comparison
  • ⚙️ Environment Configuration
  • 🎯 Selection Recommendations
  • 🛠️ Development and Debugging
  • 🔍 Troubleshooting
• AIECS Project Migration Summary
  • Completed Tasks
  • Additional Completed Work
  • Project Structure
  • Publishing Preparation
  • Usage Instructions
  • Important Notes
  • Automation Features
  • Java Environment Configuration Guide
  • Docker Configuration Guide

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
    • State Management
    • Task Execution
    • Tool Execution
    • Streaming
    • Memory Management
    • Goals Management
    • Configuration Management
    • Capabilities
    • Metrics and Performance
    • Serialization
    • Checkpointing
    • Agent Collaboration
    • Learning and Adaptation
    • Resource Management
    • Error Recovery
    • Context Management
    • Utility Methods
  • Concrete Agent Types
    • LLMAgent
    • ToolAgent
    • HybridAgent
  • ConversationMemory and Session
    • ConversationMemory
    • Session
  • ContextEngine
    • Initialization
    • Session Management
    • Conversation History
    • Compression Methods
    • Context Storage
    • Cleanup
  • Models and Configuration
    • CompressionConfig
    • CacheConfig
    • ResourceLimits
    • Experience
    • RecoveryStrategy
  • Protocols
    • LLMClientProtocol
    • ConfigManagerProtocol
    • CheckpointerProtocol
    • AgentCollaborationProtocol
  • ToolObservation
    • Fields
    • Methods
  • Enhanced Methods
    • _execute_tool_with_observation()
  • Performance Enhancement APIs
    • Caching APIs
    • Parallel Execution APIs
    • Streaming APIs
  • Reliability Enhancement APIs
    • Error Recovery APIs
    • Resource Management APIs
    • Checkpointing APIs
  • Observability Enhancement APIs
    • Metrics APIs
    • Health Status APIs
    • Operation Tracking APIs
    • Session Metrics APIs
• 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
    • 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

Knowledge Graph

• AIECS Knowledge Graph
  • Features
    • Core Capabilities (✅ Complete)
    • New Enhanced Features (✅ Complete)
    • Storage Backends
  • Quick Start
    • Basic Usage
    • Schema Management
  • Architecture
    • Two-Tier Storage Interface
    • Why This Matters
  • API Reference
  • Testing
  • Documentation
    • Getting Started
    • Reference Documentation
    • Developer Resources
    • Tutorials
    • Deployment
  • Examples
    • Tutorials
    • Example Scripts
  • Structured Data Import
    • Quick Example
  • Development
    • Project Structure
    • Contributing
  • New Features Quick Start
    • Structured Data Import
    • Search with Reranking
    • Knowledge Fusion
  • Documentation
    • Getting Started
    • Data Import
    • Search and Reasoning
    • Tools
    • Deployment
  • Performance
  • Roadmap
  • License
• AIECS Knowledge Graph User Guide
  • Introduction
    • What is a Knowledge Graph?
    • Why Use AIECS Knowledge Graph?
  • Quick Start
    • Installation
    • Your First Knowledge Graph
  • Core Concepts
    • Entities
    • Relations
    • Paths
    • Storage Backends
  • Common Tasks
    • Task 1: Building a Graph from Text
    • Task 2: Importing CSV Data
    • Task 3: Searching the Graph
    • Task 4: Multi-Hop Reasoning
    • Task 5: Knowledge Fusion
  • Schema Management
  • Best Practices
    • 1. Choose the Right Storage Backend
    • 2. Define Your Schema
    • 3. Use Meaningful IDs
    • 4. Add Metadata
    • 5. Use Knowledge Fusion
    • 6. Enable Reranking for Better Results
    • 7. Optimize Performance
  • Next Steps
  • Getting Help
• Knowledge Graph API Reference
  • Overview
  • Table of Contents
  • Domain Models
    • Entity
    • Relation
    • Path
    • GraphQuery and GraphResult
    • Evidence and ReasoningResult
    • InferenceRule
  • Schema Management
    • SchemaManager
    • EntityType and RelationType
    • PropertySchema
  • Storage Interfaces
    • GraphStore (Two-Tier Interface)
    • InMemoryGraphStore
    • SQLiteGraphStore
    • PostgreSQLGraphStore
  • Runnable Pattern
    • GraphRunnable
  • Knowledge Fusion
    • KnowledgeFusion
  • Result Reranking
    • ResultReranker
    • Reranking Strategies
  • Logical Query Parsing
    • LogicFormParser
  • Schema Caching
    • SchemaCache
  • Query Optimization
    • QueryOptimizer
  • Structured Data Pipeline
    • StructuredDataPipeline
    • SchemaInference
    • DataReshaping
    • DataQualityValidator
    • PerformanceMetrics
  • Tools
    • KnowledgeGraphBuilderTool
    • GraphSearchTool
    • GraphReasoningTool
  • See Also
• Knowledge Graph Configuration Guide
  • Overview
  • Table of Contents
  • Storage Configuration
    • Backend Selection
    • In-Memory Configuration
    • SQLite Configuration
    • PostgreSQL Configuration
  • Feature Flags
    • Runnable Pattern
    • Knowledge Fusion
    • Result Reranking
    • Logical Queries
    • Structured Data Import
  • Knowledge Fusion Configuration
    • Similarity Threshold
    • Conflict Resolution Strategy
  • Reranking Configuration
    • Default Strategy
    • Top-K Configuration
  • Cache Configuration
    • Query Cache
    • Schema Cache
  • Query Optimization
    • Enable Optimization
    • Optimization Strategy
  • Environment Variables
    • Complete Reference
  • Configuration Examples
    • Development Setup
    • Testing Setup
    • Production Setup
    • High-Performance Setup
    • Data Quality Setup
  • Best Practices
    • 1. Start Simple
    • 2. Monitor Performance
    • 3. Tune Gradually
    • 4. Environment-Specific Configs
    • 5. Security Considerations
  • Troubleshooting
    • Slow Queries
    • High Memory Usage
    • Too Many Duplicate Entities
    • Poor Search Results
  • See Also
• Knowledge Graph Configuration Guide
  • Table of Contents
  • Quick Start
    • Minimal Configuration (In-Memory)
    • Development Configuration (SQLite)
    • Production Configuration (PostgreSQL)
  • Storage Backends
    • 1. In-Memory (Default)
    • 2. SQLite
    • 3. PostgreSQL (Recommended for Production)
  • Environment Variables
    • Core Configuration
    • SQLite Configuration
    • PostgreSQL Configuration
    • In-Memory Configuration
    • Query Configuration
    • Cache Configuration
  • Configuration Properties
  • Backend-Specific Configuration
    • PostgreSQL: Using Main Database
    • PostgreSQL: Separate Database
    • PostgreSQL: Cloud Database (Connection String)
    • PostgreSQL: Connection Pooling
    • PostgreSQL: pgvector Extension
    • SQLite: Memory vs. File
  • Query Configuration
    • Search Limits
    • Traversal Depth
    • Vector Dimensions
  • Cache Configuration
    • Enable/Disable Caching
    • Cache TTL
  • Validation
    • Automatic Validation
    • Manual Validation
    • Validation Rules
  • Examples
    • Example 1: Development Setup (SQLite)
    • Example 2: Production Setup (PostgreSQL)
    • Example 3: Testing Setup (In-Memory)
    • Example 4: Programmatic Configuration
    • Example 5: Multi-Environment Setup
  • Troubleshooting
    • Issue: PostgreSQL connection fails
    • Issue: SQLite file not found
    • Issue: Vector search returns no results
    • Issue: Queries are slow
  • Best Practices
  • Migration
  • See Also
• Knowledge Graph Performance Guide
  • Overview
  • Table of Contents
  • Structured Data Import Performance
    • CSV Import Benchmarks
    • JSON Import Benchmarks
    • Import Performance Factors
  • Reranking Performance
    • Strategy Latency Comparison
    • Reranking Overhead
    • Scaling Characteristics
  • Schema Caching Performance
    • Cache Hit Rate
    • Performance Improvement
    • Cache Configuration
  • Query Optimization Performance
    • Optimization Time Reduction
    • Optimization Strategies
  • Knowledge Fusion Performance
    • Fusion Throughput
    • Similarity Threshold Impact
    • Conflict Resolution Performance
  • Performance Comparison
    • Before vs. After Optimizations
  • Optimization Recommendations
    • 1. Structured Data Import
    • 2. Search and Reranking
    • 3. Schema Caching
    • 4. Query Optimization
    • 5. Knowledge Fusion
  • See Also
• Runnable Pattern Guide
  • Overview
  • Table of Contents
  • Why Use Runnable?
  • Core Features
  • Quick Start
    • Basic Example
  • Lifecycle Management
    • Lifecycle Methods
    • State Transitions
  • Configuration
    • Basic Configuration
    • Custom Configuration
    • Configuration Validation
  • Error Handling & Retry Logic
    • Automatic Retries
    • Retry Behavior
    • Execute vs Run
    • Custom Error Handling
  • Circuit Breaker Pattern
    • How It Works
    • Configuration
    • Use Cases
  • Timeout Support
    • Execution Timeout
    • No Timeout
  • Metrics & Monitoring
    • Built-in Metrics
    • Reset Metrics
    • Integration with Monitoring Systems
  • Advanced Usage
    • Async Context Manager
    • Multiple Executions
    • Composition
  • Best Practices
    • 1. Use Context Managers
    • 2. Use run() in Production
    • 3. Configure Retries Appropriately
    • 4. Validate Configuration Early
    • 5. Handle Resources Properly
    • 6. Log Appropriately
  • Real-World Examples
    • Example 1: API Client Component
    • Example 2: Data Processing Pipeline
    • Example 3: Knowledge Graph Builder Component
  • Summary
  • See Also
• Schema Mapping Configuration Guide
  • Table of Contents
  • Overview
  • Basic Concepts
    • SchemaMapping
    • EntityMapping
    • RelationMapping
  • Entity Mapping
    • Simple Entity Mapping
    • Entity Mapping with ID Column
    • Multiple Entity Types from Same Row
  • Relation Mapping
    • Basic Relation Mapping
    • Relation with Properties
  • Property Transformations
    • Transformation Types
    • RENAME Transformation
    • TYPE_CAST Transformation
    • COMPUTE Transformation
    • CONSTANT Transformation
    • SKIP Transformation
  • Complete Examples
    • Example 1: Employee Data
    • Example 2: Product Catalog
    • Example 3: Complex Transformations
  • Best Practices
    • 1. Always Specify ID Columns
    • 2. Use Type Casting for Numeric Data
    • 3. Validate Mappings Before Use
    • 4. Handle Missing Columns Gracefully
    • 5. Use Transformations for Data Cleaning
    • 6. Document Your Mappings
  • Common Patterns
    • Pattern 1: One Entity Per Row
    • Pattern 2: Multiple Entities Per Row
    • Pattern 3: Relations from Same Row
    • Pattern 4: Nested JSON
  • Troubleshooting
    • Issue: Entities Not Created
    • Issue: Relations Not Created
    • Issue: Type Casting Fails
    • Issue: Computed Values Wrong
  • Next Steps
• StructuredDataPipeline Usage Guide
  • Table of Contents
  • Quick Start
  • Basic Usage
    • Step 1: Define Schema Mapping
    • Step 2: Initialize Graph Store
    • Step 3: Create Pipeline
    • Step 4: Import Data
    • Step 5: Check Results
  • CSV Import
    • Basic CSV Import
    • CSV with Custom Delimiter
    • CSV with Headers
    • CSV with Different Encoding
  • SPSS Import
    • Basic SPSS Import
    • SPSS Import with Schema Mapping
    • SPSS Metadata Preservation
    • Auto-detect File Format
  • Excel Import
    • Basic Excel Import
    • Excel Import with Specific Sheet
    • Excel Import with Multiple Sheets
    • Excel Data Types
  • Automatic Schema Inference
    • Infer Schema from Data
    • Infer Schema from SPSS
    • Partial Schema Inference
    • Import with Auto-Inference
  • Data Reshaping
    • Wide-to-Long Conversion for Normalized Structures
    • Automatic Reshaping During Import
    • Reshape and Import in One Step
  • Statistical Aggregation
    • Compute Statistics During Import
    • Grouped Aggregation
  • Data Quality Validation
    • Range Validation
    • Outlier Detection
    • Completeness Checks
  • JSON Import
    • JSON Array Import
    • JSON Lines (NDJSON) Import
    • JSON Object with Array Property
    • JSON from String
  • Batch Processing
  • Error Handling
    • Skip Errors (Default)
    • Fail on First Error
    • Validate Before Import
  • Advanced Features
    • Progress Callback
    • Custom Metadata
    • Multiple Imports
    • Incremental Import
  • Performance Optimization
    • Parallel Processing
    • Bulk Write Operations
    • Streaming Import for Large Files
    • Batch Size Auto-Tuning
    • Performance Metrics
  • Performance Tips
    • 1. Use Batch Processing
    • 2. Optimize Schema Mapping
    • 3. Use Appropriate Storage Backend
    • 4. Pre-process Large Files
    • 5. Validate Before Import
  • Complete Example
  • Next Steps
• Knowledge Graph Troubleshooting Guide
  • Common Issues and Solutions
    • Import Issues
    • Search and Reranking Issues
    • Knowledge Fusion Issues
    • Performance Issues
    • Configuration Issues
    • Tool Issues
  • Getting Help
  • Performance Benchmarks
• End-to-End Knowledge Graph Tutorial
  • Overview
  • Scenario
  • Prerequisites
  • Step 1: Prepare Your Data
    • employees.csv
    • projects.json
  • Step 2: Initialize the System
  • Step 3: Import CSV Data
  • Step 4: Import JSON Data
  • Step 5: Add Unstructured Text
  • Step 6: Merge Duplicate Entities
  • Step 7: Search with Reranking
  • Step 8: Parse Logical Queries
  • Step 9: Get Statistics
  • Step 10: Cleanup
  • Complete Example
  • Next Steps
  • Performance Tips
• Multi-Hop Reasoning Tutorial
  • Overview
  • Learning Objectives
  • What is Multi-Hop Reasoning?
  • Scenario: Corporate Knowledge Graph
  • Step 1: Build the Knowledge Graph
  • Step 2: Simple Path Finding (2-Hop)
  • Step 3: Multi-Hop Question Answering
  • Step 4: Evidence-Based Reasoning
  • Step 5: Complete Example
  • Key Concepts
    • 1. Path Finding
    • 2. Multi-Hop Traversal
    • 3. Query Planning
    • 4. Evidence Synthesis
  • Best Practices
  • Performance Tips
  • Next Steps
  • Resources
• Building a Domain-Specific Knowledge Graph Tutorial
  • Overview
  • Learning Objectives
  • Scenario: Medical Knowledge Graph
  • Step 1: Define Your Domain Schema
  • Step 3: Create Custom Relation Extractor
  • Step 4: Build the Knowledge Graph
  • Step 5: Query Your Domain Knowledge
  • Step 6: Add Domain-Specific Inference Rules
  • Step 7: Complete Example
  • Key Takeaways
  • Next Steps
  • Resources
• Knowledge Graph Visualization Examples
  • Overview
  • Table of Contents
  • Export to DOT (Graphviz)
    • Basic Export
    • Render with Graphviz
    • Customize DOT Output
  • Export to JSON (D3.js)
    • D3.js Force-Directed Graph
    • HTML Visualization with D3.js
  • Export to Cytoscape.js
    • Export to Cytoscape Format
    • HTML Visualization with Cytoscape.js
  • Export to Mermaid
    • Generate Mermaid Diagram
    • Use in Markdown
    • Render with Mermaid CLI
  • Visualize Paths
    • Export Single Path
  • Interactive Visualizations
    • Complete Example
  • See Also
• JSON-to-Graph Tutorial
  • Scenario
  • Sample Data Formats
    • Format 1: JSON Array
    • Format 2: JSON Lines (NDJSON)
    • Format 3: Object with Array Property
  • Step 1: Create Schema Mapping
  • Step 2: Initialize Graph Store
  • Step 3: Create Pipeline
  • Step 4: Import JSON
    • Import JSON Array
    • Import JSON Lines
    • Import Object with Array Property
    • Import from String
  • Complete Example: JSON Array
  • Advanced: Nested JSON Structures
  • Advanced: Relations from JSON
  • Handling Complex JSON Types
    • Arrays
    • Objects
  • Troubleshooting
    • Issue: “JSON decode error”
    • Issue: “Array key not found”
    • Issue: “Field not found”
  • Performance Tips
    • 1. Use JSON Lines for Large Files
    • 2. Batch Processing
    • 3. Validate Before Import
  • Next Steps
• CSV-to-Graph Tutorial
  • Scenario
  • Sample Data
  • Step 1: Install Dependencies
  • Step 2: Create Schema Mapping
  • Step 3: Initialize Graph Store
  • Step 4: Create Pipeline
  • Step 5: Import CSV
  • Step 6: Query the Graph
  • Complete Example
  • Advanced: Multiple Entity Types
  • Advanced: Relations
  • Troubleshooting
    • Issue: “Column not found”
    • Issue: Type casting fails
    • Issue: Entities not created
  • Next Steps
• Knowledge Graph Builder Tool
  • Overview
  • Features
  • Tool Registration
  • Input Schema
    • KnowledgeGraphBuilderInput
  • Actions
    • 1. Build from Text
    • 2. Build from Document
    • 3. Build from Structured Data (NEW)
    • 4. Get Statistics
  • Advanced Usage
    • Combining Actions
    • Error Handling
  • Best Practices
    • 1. Choose the Right Action
    • 2. Schema Mapping Tips
    • 3. Performance Optimization
    • 4. Data Quality
  • See Also
• Graph Reasoning Tool
  • Overview
  • Features
  • Tool Registration
  • Input Schema
    • GraphReasoningInput
  • Modes
    • 1. Query Plan Mode
    • 2. Multi-Hop Reasoning Mode
    • 3. Inference Mode
    • 4. Evidence Synthesis Mode
    • 5. Logical Query Mode
    • 6. Full Reasoning Mode
  • Use Cases
    • 1. Simple Query Planning
    • 2. Path Finding
    • 3. Transitive Inference
    • 4. Complete Reasoning
  • Optimization Strategies
    • Cost Optimization
    • Latency Optimization
    • Balanced Optimization
  • Evidence Synthesis Methods
    • Weighted Average (Default)
    • Max
    • Voting
  • Error Handling
    • Missing Required Parameters
    • Inference Requires Relation Type
  • Default Inference Rules
  • Performance Considerations
  • Integration with AIECS Agents
  • Related Tools
  • Examples
  • API Reference
    • GraphReasoningTool
• Graph Search Tool Documentation
  • Overview
  • Tool Registration
  • Features
  • Input Schema
    • Required Parameters
    • Optional Parameters
    • Reranking Parameters
  • Output Format
    • Success Response
    • Error Response
  • Usage Examples
    • Example 1: Vector Search
    • Example 2: Graph Search
    • Example 3: Hybrid Search
    • Example 4: PageRank Search
    • Example 5: Multi-Hop Search
    • Example 6: Filtered Search
    • Example 7: Pattern-Based Traversal
    • Example 8: Search with Reranking
  • Advanced Usage
    • Combining with Other Tools
    • Caching for Performance
    • Entity Type Filtering
  • Performance Considerations
    • Search Mode Performance
    • Optimization Tips
  • Error Handling
    • Common Errors
    • Error Recovery
  • Integration with Agent Workflows
    • Agentic Pattern 1: Exploratory Search
    • Agentic Pattern 2: Ranked Discovery
    • Agentic Pattern 3: Multi-Modal Search
  • Testing
  • See Also
  • Support
• Agent Integration with Knowledge Graph
  • Overview
  • Agent Types
    • 1. HybridAgent (Original)
    • 2. KnowledgeAwareAgent (Enhanced)
    • 3. GraphAwareAgentMixin (Reusable)
  • Integration Patterns
    • Pattern 1: Direct Integration
    • Pattern 2: Mixin Integration
    • Pattern 3: Conditional Integration
  • Graph Store Options
    • InMemoryGraphStore
    • SQLiteGraphStore
  • Available Tools
    • GraphSearchTool
    • GraphReasoningTool
  • Knowledge-Augmented ReAct Loop
    • Retrieval Strategies
    • Caching
  • Best Practices
    • 1. Graph Store Initialization
    • 2. Graceful Degradation
    • 3. Knowledge Formatting
    • 4. Error Handling
    • 5. Resource Cleanup
  • Performance Considerations
    • Knowledge Retrieval
    • Graph Store Selection
    • Query Optimization
  • Troubleshooting
    • Graph Store Not Available
    • Knowledge Not Retrieved
    • Tool Not Found
  • Next Steps
• Knowledge Retrieval Usage Examples
  • Table of Contents
  • Basic Knowledge Retrieval
    • Example 1: Simple Knowledge Query
    • Example 2: Using Different Retrieval Strategies
    • Example 3: Manual Knowledge Retrieval
  • Custom Retrieval Strategy
    • Example 1: Per-Query Strategy Override
    • Example 2: Providing Seed Entities
    • Example 3: Custom Cache Configuration
  • Monitoring and Metrics
    • Example 1: Basic Metrics Tracking
    • Example 2: Strategy Usage Analysis
    • Example 3: Performance Monitoring
    • Example 4: Entity Extraction Metrics
  • Advanced Patterns
    • Example 1: Streaming Events
    • Example 2: Cache Performance Analysis
    • Example 3: Strategy Comparison
    • Example 4: Error Handling and Fallback
  • Best Practices
    • 1. Choose Appropriate Strategy
    • 2. Configure Caching Wisely
    • 3. Monitor Performance
    • 4. Handle Errors Gracefully
  • Related Documentation
• Knowledge Retrieval Configuration Guide
  • Table of Contents
  • Configuration Overview
    • Basic Configuration
  • Retrieval Strategy Options
    • Available Strategies
    • Strategy Selection Guidelines
  • Caching Configuration
    • Configuration Options
    • Cache Invalidation
  • Entity Extraction Configuration
    • Configuration Option
  • Performance Tuning
    • max_context_size
    • Context Prioritization
  • Configuration Examples
    • Example 1: Fast Semantic Search
    • Example 2: Comprehensive Graph Exploration
    • Example 3: Balanced Hybrid Search
    • Example 4: Auto Strategy with Custom Cache
  • Environment Variables
  • Best Practices
    • 1. Choose Strategy Based on Query Type
    • 2. Tune Cache TTL Based on Data Stability
    • 3. Balance Context Size
    • 4. Monitor Performance
  • Troubleshooting
    • Issue: Retrieval Strategy Not Working
    • Issue: Cache Not Working
    • Issue: Too Many/Few Entities Retrieved
  • Related Documentation
• Knowledge Retrieval Metrics and Monitoring
  • Table of Contents
  • Overview
  • Available Metrics
    • Query Metrics
    • Performance Metrics
    • Cache Metrics
    • Strategy Metrics
    • Entity Extraction Metrics
  • Accessing Metrics
    • Method 1: Via get_metrics()
    • Method 2: Direct Access
    • Method 3: Via get_graph_metrics()
  • Monitoring Patterns
    • Pattern 1: Basic Metrics Tracking
    • Pattern 2: Performance Monitoring
    • Pattern 3: Cache Effectiveness Monitoring
• Knowledge Graph Reasoning Engine
  • Overview
  • Architecture
  • Components
    • 1. Query Planner
    • 2. Multi-Hop Reasoning Engine
    • 3. Inference Engine
    • 4. Evidence Synthesizer
  • Reasoning Workflow
    • Complete Reasoning Pipeline
    • Step-by-Step Workflow
  • Domain Models
    • QueryPlan
    • QueryStep
    • ReasoningResult
    • Evidence
    • InferenceResult
  • Use Cases
    • 1. Complex Question Answering
    • 2. Relationship Discovery
    • 3. Evidence-Based Decision Making
    • 4. Knowledge Graph Completion
  • Performance
    • Benchmarks
    • Optimization Tips
  • Best Practices
    • Query Writing
    • Inference Rules
    • Evidence Synthesis
  • Error Handling
  • Testing
  • API Reference
    • QueryPlanner
    • ReasoningEngine
    • InferenceEngine
    • EvidenceSynthesizer
  • Examples
  • Related Documentation
• Type Enum Usage Guide
  • Overview
  • Generating Type Enums
    • Basic Usage
    • Enum Structure
  • Using Type Enums
    • In Queries
    • In Function Signatures
    • In Validation
    • In Pattern Matching
  • Backward Compatibility
    • String Compatibility
    • Existing Code
  • Benefits of Type Enums
    • 1. Type Safety
    • 2. IDE Autocomplete
    • 3. Refactoring Support
    • 4. Documentation
  • Advanced Usage
    • Iterating Over Enums
    • Enum Comparison
    • Dynamic Enum Access
  • Best Practices
    • 1. Generate Enums Once
    • 2. Use Type Hints
    • 3. Prefer Enums in New Code
    • 4. Document Enum Usage
  • Migration Guide
    • Migrating Existing Code
    • No Breaking Changes
  • Conclusion
• Query Optimization Guide
  • Overview
  • Query Optimization Techniques
    • 1. Use Schema Caching
    • 2. Limit Result Sets
    • 3. Use Specific Filters
    • 4. Optimize Traversal Depth
    • 5. Use Batch Operations
    • 6. Use Projection
    • 7. Use Aggregation
    • 8. Optimize Pattern Matching
    • 9. Use Type Enums
    • 10. Reuse Query Plans
  • Query Anti-Patterns
    • 1. N+1 Query Problem
    • 2. Fetching Too Much Data
    • 3. Deep Traversals
  • Performance Benchmarks
    • Query Types
    • Optimization Impact
  • Monitoring Query Performance
    • Enable Query Logging
    • Track Query Metrics
  • Conclusion
• Schema Caching Guide
  • Overview
  • What is Schema Caching?
  • Benefits
  • Enabling Schema Caching
    • Default Configuration
    • Custom Cache Configuration
    • Disabling Cache
  • Cache Sizing Guidelines
    • Small Schema (< 50 types)
    • Medium Schema (50-200 types)
    • Large Schema (200+ types)
  • Cache Operations
    • Warming the Cache
    • Clearing the Cache
    • Cache Metrics
    • Reset Metrics
  • Performance Impact
    • Benchmark Results
  • Best Practices
    • 1. Enable Caching in Production
    • 2. Size Caches Appropriately
    • 3. Warm Cache on Startup
    • 4. Monitor Cache Performance
    • 5. Clear Cache on Schema Updates
  • Troubleshooting
    • Low Hit Rate
    • High Memory Usage
    • Stale Cache Data
  • Conclusion
• Reranking Strategies Guide
  • Overview
  • Built-in Strategies
    • 1. TextSimilarityReranker
    • 2. SemanticReranker
    • 3. StructuralReranker
    • 4. HybridReranker
  • Strategy Comparison
  • Combining Strategies
    • Using ResultReranker
    • Combination Methods
  • Best Practices
    • 1. Choose the Right Strategy
    • 2. Tune Weights
    • 3. Normalize Scores
    • 4. Use Top-K Limiting
    • 5. Cache When Possible
  • Custom Strategies
    • Creating a Custom Strategy
    • Using Custom Strategy
  • Use Cases
    • Use Case 1: Academic Paper Search
    • Use Case 2: Product Search
    • Use Case 3: Expert Finding
    • Use Case 4: News Article Search
  • Performance Optimization
    • 1. Batch Processing
    • 2. Caching
    • 3. Parallel Strategy Execution
    • 4. Early Stopping
  • Troubleshooting
    • Problem: Low Scores for All Entities
    • Problem: One Strategy Dominates
    • Problem: Slow Performance
    • Problem: Missing Embeddings
  • Testing Strategies
    • Unit Testing
    • Integration Testing
  • Conclusion
• ResultReranker API Documentation
  • Overview
  • Core Classes
    • ResultReranker
    • RerankerStrategy (Abstract Base Class)
    • ScoreCombinationMethod (Enum)
  • Utility Functions
    • normalize_scores()
    • combine_scores()
  • Complete Example
  • Type Hints
  • Thread Safety
• Logic Query Parser Documentation
  • Overview
  • Features
  • Quick Start
    • Installation
    • Basic Usage
  • Query Syntax
    • Find Clause
    • WHERE Clause
    • FOLLOWS Clause
    • Complex Queries
  • API Reference
    • LogicQueryParser
    • ParserError
  • Error Handling
    • Phase 1: Syntax Errors (Fatal)
    • Phase 2: Semantic Errors (Accumulated)
  • Error Messages with Suggestions
  • Thread Safety
  • Performance
    • Parser Caching
  • Examples
    • Example 1: Simple Entity Lookup
    • Example 2: Filter by Age
    • Example 3: Boolean Logic
    • Example 4: Graph Traversal
    • Example 5: Error Handling
  • Grammar Reference
  • Next Steps
  • Related Documentation
  • Support
• Logic Query DSL Grammar Documentation
  • Overview
  • Grammar Structure
    • Top-Level Query
    • Find Clause - Entity Selection
    • Traversal Clause - Graph Navigation
    • Where Clause - Filtering
    • Property Paths
    • Operators
    • Values and Literals
  • Complete Examples
    • Example 1: Simple Entity Lookup
    • Example 2: Entity with Name
    • Example 3: Filter by Property
    • Example 4: Multiple Filters with AND
    • Example 5: Multiple Filters with OR
    • Example 6: Complex Boolean Logic
    • Example 7: NOT Operator
    • Example 8: IN Operator
    • Example 9: CONTAINS Operator
    • Example 10: Single-Hop Traversal
    • Example 11: Multi-Hop Traversal
    • Example 12: Traversal with Direction
    • Example 13: Traversal with Filter
    • Example 14: Nested Properties
    • Example 15: Complex Query
  • Grammar Validation
  • Operator Precedence Table
  • Reserved Keywords
  • Terminal Symbols
  • Future Extensions
  • References
• Knowledge Graph Search Strategies
  • Overview
  • Search Strategy Types
    • 1. Vector Search
    • 2. Graph Structure Search
    • 3. Hybrid Search
    • 4. Personalized PageRank
    • 5. Multi-Hop Retrieval
    • 6. Filtered Retrieval
    • 7. Pattern-Based Traversal
  • Strategy Comparison
  • Combining Strategies
    • Pattern 1: Vector → Graph
    • Pattern 2: PageRank → Filter
    • Pattern 3: Hybrid with Caching
  • Performance Optimization
    • 1. Use Appropriate Strategy
    • 2. Limit Search Scope
    • 3. Set Reasonable Limits
    • 4. Enable Caching
    • 5. Batch Operations
  • Best Practices
  • See Also
• Production Deployment Guide for Knowledge Graph
  • Table of Contents
  • Prerequisites
    • System Requirements
    • Software Requirements
  • Backend Selection
    • When to Use Each Backend
  • PostgreSQL Setup
    • 1. Install PostgreSQL
    • 2. Configure PostgreSQL
    • 3. Configure Connection Pooling
    • 4. Configure Firewall
  • Configuration
    • Environment Variables
    • Application Configuration
  • Performance Optimization
    • 1. Enable Caching
    • 2. Optimize Indexes
    • 3. Use Batch Operations
    • 4. Configure Connection Pooling
  • Monitoring and Health Checks
    • 1. Health Checks
    • 2. Metrics Collection
    • 3. Performance Monitoring
  • Security
    • 1. Database Security
    • 2. Connection Security
    • 3. Input Validation
  • Backup and Recovery
    • 1. PostgreSQL Backup
    • 2. Restore from Backup
    • 3. Streaming Backup
  • Scaling
    • Vertical Scaling
    • Horizontal Scaling
  • Troubleshooting
    • Common Issues
  • Production Checklist
  • Next Steps
• Security Review and Validation for Knowledge Graph
  • Security Checklist
    • ✅ Input Validation
    • ✅ Authentication and Authorization
    • ✅ Data Protection
    • ✅ Injection Prevention
    • ✅ Error Handling
    • ✅ Access Control
    • ✅ Monitoring and Auditing
  • Security Best Practices
    • 1. Credential Management
    • 2. Connection Security
    • 3. Input Validation
    • 4. Error Handling
  • Security Testing
    • 1. SQL Injection Testing
    • 2. Input Validation Testing
    • 3. Access Control Testing
  • Security Configuration
    • PostgreSQL Security
    • Application Security
  • Incident Response
    • Security Incident Checklist
  • Compliance Considerations
    • GDPR
    • SOC 2
    • HIPAA (if applicable)
  • Security Resources
  • Summary
• Backend Configuration Guide
  • Backend Selection Matrix
  • InMemoryGraphStore
    • When to Use
    • Configuration
    • Characteristics
  • SQLiteGraphStore
    • When to Use
    • Configuration
    • Performance Tuning
    • Characteristics
  • PostgresGraphStore
    • When to Use
    • Configuration
    • Environment Variables
    • Characteristics
  • Backend Selection Decision Tree
  • Migration Between Backends
    • Using GraphStorageMigrator
    • Manual Migration
  • Configuration Examples
    • Development Environment
    • Testing Environment
    • Staging Environment
    • Production Environment
  • Backend-Specific Features
    • InMemoryGraphStore
    • SQLiteGraphStore
    • PostgresGraphStore
  • Performance Comparison
  • Best Practices
    • 1. Choose the Right Backend
    • 2. Connection Pooling (PostgreSQL)
    • 3. Environment-Specific Configuration
    • 4. Graceful Degradation
  • Troubleshooting
    • SQLite: Database Locked
    • PostgreSQL: Connection Pool Exhausted
    • InMemory: Out of Memory
  • Summary
• Graph Storage Performance Guide
  • Quick Start
    • Enable All Optimizations
  • 1. Caching
    • Redis Configuration
    • Usage Patterns
    • Performance Impact
  • 2. Batch Operations
    • Bulk Insertion
    • Bulk Deletion
    • Optimal Batch Size
    • Performance Impact
  • 3. Index Optimization
    • Analyze Indexes
    • Get Recommendations
    • Apply Optimizations
    • Full Optimization Report
    • Maintenance
  • 4. Performance Monitoring
    • Setup
    • Track Queries
    • Analyze Query Plans
    • Performance Reports
    • Prepared Statement Caching
  • 5. Benchmarking
    • Run Benchmarks
    • Custom Benchmarks
  • Best Practices
    • 1. Choose the Right Backend
    • 2. Optimize for Your Workload
    • 3. Monitor and Tune
    • 4. Optimize Indexes Regularly
  • Performance Checklist
    • Initial Setup
    • For Production
    • For Development
  • Troubleshooting
    • Slow Queries
    • Cache Not Working
    • High Memory Usage
  • Summary
    • Performance Gains
    • Quick Wins
    • Next Steps

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 - Configuration Reference
  • Table of Contents
  • 1. Configuration Overview
    • 1.1 Configuration Methods
    • 1.2 Configuration Priority
  • 2. Configuration Parameters
    • 2.1 Complete Parameter Reference
    • 2.2 Parameter Details
  • 3. API Credentials
    • 3.1 FRED API Key
    • 3.2 News API Key
    • 3.3 The Guardian API Key
    • 3.4 Census Bureau API Key
    • 3.4 Congress.gov API
    • 3.5 OpenStates API
    • 3.6 World Bank API
    • 3.7 Alpha Vantage API Key
    • 3.8 REST Countries API
    • 3.9 ExchangeRate-API
    • 3.10 Open Library API
    • 3.11 Metropolitan Museum of Art (The Met) API
    • 3.12 CoinGecko API
    • 3.12 OpenWeatherMap API
    • 3.13 Wikipedia API
    • 3.14 GitHub API
    • 3.13 arXiv API
    • 3.14 PubMed/NCBI E-utilities API
    • 3.15 CrossRef API
    • 3.16 Semantic Scholar API
    • 3.17 CORE API Key
    • 3.18 USPTO API Key
    • 3.19 SEC EDGAR API
    • 3.20 Stack Exchange API
    • 3.21 OpenCorporates API
    • 3.22 CourtListener (Free Law Project) API
    • 3.23 GBIF (Global Biodiversity Information Facility) API
  • 4. Performance Settings
    • 4.1 Caching Configuration
    • 4.2 Timeout Configuration
    • 4.3 Retry Configuration
  • 5. Feature Flags
    • 5.1 Query Enhancement
    • 5.2 Fallback Strategy
    • 5.3 Data Fusion
    • 5.4 Rate Limiting
  • 6. Provider-Specific Configuration
    • 6.1 FRED Provider
    • 6.2 World Bank Provider
    • 6.3 News API Provider
    • 6.4 The Guardian Provider
    • 6.5 Census Provider
    • 6.5 Congress Provider
    • 6.6 OpenStates Provider
    • 6.7 Alpha Vantage Provider
    • 6.6 REST Countries Provider
    • 6.7 ExchangeRate Provider
    • 6.8 Open Library Provider
    • 6.9 Metropolitan Museum of Art (The Met) Provider
    • 6.10 CoinGecko Provider
    • 6.10 OpenWeatherMap Provider
    • 6.11 Wikipedia Provider
    • 6.12 GitHub Provider
    • 6.13 arXiv Provider
    • 6.14 PubMed Provider
    • 6.15 CrossRef Provider
    • 6.16 Semantic Scholar Provider
    • 6.17 CORE Provider
    • 6.18 USPTO Provider
    • 6.19 SEC EDGAR Provider
    • 6.20 Stack Exchange Provider
    • 6.21 Hacker News Provider
    • 6.22 OpenCorporates Provider
    • 6.23 GDELT Project Provider
    • 6.24 DuckDuckGo Zero-Click Info Provider
  • 7. Environment Variables
    • 7.1 Variable Reference
    • 7.2 Loading from .env File
  • 8. Configuration Examples
    • 8.1 Development Configuration
    • 8.2 Production Configuration
    • 8.3 High-Volume Configuration
    • 8.4 Minimal Configuration
  • 9. Validation and Testing
    • 9.1 Configuration Validation
    • 9.2 Testing Configuration
    • 9.3 Configuration Best Practices
• APISource Tool - Developer Guide
  • Table of Contents
  • 1. Quick Start
    • 5-Minute Setup
    • What You Get
  • 2. Installation
    • Prerequisites
    • API Keys Setup
    • Configuration File
  • 3. Basic Usage
    • 3.1 FRED Provider - Economic Data
    • 3.2 World Bank Provider - Global Development
    • 3.3 News API Provider - News Articles
    • 3.4 Census Provider - US Demographics
  • 4. Advanced Usage
    • 4.1 Query Enhancement
    • 4.2 Multi-Provider Search
    • 4.3 Fallback Strategy
    • 4.4 Data Fusion
    • 4.5 Batch Queries
  • 5. LangChain Integration
    • 5.1 Basic Integration
    • 5.2 Provider-Specific Tools
    • 5.3 Custom Tool Configuration
  • 6. Best Practices
    • 6.1 API Key Management
    • 6.2 Error Handling
    • 6.3 Performance Optimization
    • 6.4 Data Quality Checks
  • 7. Common Patterns
    • 7.1 Economic Research Assistant
    • 7.2 News Aggregator
    • 7.3 Multi-Source Data Aggregator
  • 8. Troubleshooting
    • 8.1 Common Issues
    • 8.2 Debugging
• APISource 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 Design Principles
  • 3. Core Components
    • 3.1 APISourceTool Class
    • 3.2 Provider Registry
  • 4. Providers
    • 4.1 BaseAPIProvider
    • 4.2 Rate Limiter
    • 4.3 FRED Provider
    • 4.4 World Bank Provider
    • 4.5 News API Provider
    • 4.6 Census Provider
  • 5. Intelligence Features
    • 5.1 Query Intent Analyzer
    • 5.2 Query Enhancer
    • 5.3 Data Fusion Engine
    • 5.4 Search Enhancer
  • 6. Reliability Mechanisms
    • 6.1 Smart Error Handler
    • 6.2 Fallback Strategy
  • 7. API Reference
    • 7.1 Core Operations
    • 7.2 Provider Management
    • 7.3 Monitoring Operations
  • 8. Data Structures
    • 8.1 Result Structure
    • 8.2 Exception Hierarchy
  • 9. Advanced Topics
    • 9.1 Adding Custom Providers
    • 9.2 Custom Fusion Strategies
    • 9.3 Performance Optimization
• 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
    • 5.2 Monitoring Operations
    • 5.3 Context Operations
  • 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
    • Return Result
    • Agent Invocation Example
  • 3. chart_export_data
    • Function Description
    • Supported Export Formats
    • LangChain Invocation Method
    • Input Parameters
    • Use Cases
    • 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
    • Advanced Analysis Operations
  • 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 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 Content Length
    • 3. Output Directory
    • 4. Scrapy Command
    • 5. Allowed Domains
    • 6. Blocked Domains
    • 7. Use Stealth Mode
    • 8. Playwright Available (Read-Only)
  • Usage Examples
    • Example 1: Basic Environment Configuration
    • Example 2: Security-Focused Configuration
    • Example 3: Development Configuration
    • Example 4: Programmatic Configuration
    • Example 5: Stealth Mode Configuration
    • Example 6: Mixed Configuration
  • Configuration Priority
  • Data Type Parsing
    • String Values
    • Integer Values
    • List Values
  • Validation
    • Automatic Type Validation
    • Runtime Validation
  • Operations Supported
    • HTTP Clients
    • JavaScript Rendering
    • HTML Parsing
    • Scrapy Integration
    • Output Formats
  • Troubleshooting
    • Issue: SSL certificate errors
    • Issue: Playwright not available
    • Issue: Scrapy command not found
    • Issue: Content too large
    • Issue: Domain not allowed
    • Issue: Rate limiting
    • Issue: Timeout errors
    • Issue: List parsing error
    • Issue: Output directory not writable
    • Issue: Stealth mode not working
    • Issue: Bot detection still occurring with stealth mode
  • Best Practices
    • Web Scraping Ethics
    • Security
    • Performance
    • Error Handling
    • Development vs Production
    • Error Handling
  • Installation Requirements
    • Core Dependencies
    • Playwright Setup
    • Stealth Mode Setup
    • Scrapy Setup
    • Verification
  • Related Documentation
  • Support
• 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
    • AI Orchestration Tools
  • 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
  • 📊 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
    • ClassFire Tool (Text Classification and Keyword Extraction Tool)
    • Office Tool (Office Document Processing Tool)
    • Stats Tool (Statistical Analysis Tool)
    • Report Tool (Multi-format Report Generation Tool)
  • Scraper Tool (Web Scraping Tool)
    • Feature Overview
    • Special Dependency Instructions
    • Usage Examples
    • Feature Classification
    • Notes
    • Troubleshooting
• 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
    • 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
    • 5.2 Decorator Functions
    • 5.3 Exception Classes
    • 5.4 Configuration Class
  • 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.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
    • 5.2 Attributes
  • 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.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
    • 5.2 ToolRegistry Class
    • 5.3 Convenience Functions
  • 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.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
    • 5.2 Decorators
    • 5.3 Internal Methods
  • 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.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
  • 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
    • 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
    • 4.2 Streaming Text Generation
    • 4.3 Task Processing Integration
    • 4.4 Content Analysis and Processing
    • 4.5 Batch Processing
  • 5. API Reference
    • 5.1 Data Class Definitions
    • 5.2 Exception Class Definitions
    • 5.3 Abstract Base Class
    • 5.4 Abstract Methods
    • 5.5 Utility Methods
  • 6. Technical Implementation Details
    • 6.1 Abstract Base Class Design
    • 6.2 Data Class Design
    • 6.3 Error Handling Mechanism
    • 6.4 Cost Estimation Mechanism
    • 6.5 Context Management
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Concrete Implementation Examples
    • 7.3 Docker Deployment
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues and Solutions
  • 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
    • 5.2 OpenAIClient
    • 5.3 VertexAIClient
    • 5.4 XAIClient
  • 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.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
    • 5.2 DetailedRedisTokenCallbackHandler
    • 5.3 CompositeCallbackHandler
    • 5.4 Convenience Functions
  • 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.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
    • 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
    • Debugging Tips
    • Performance Optimization
• API Reference
  • Table of Contents
  • Core Managers
    • CommunityManager
    • DecisionEngine
    • ResourceManager
    • CollaborativeWorkflowEngine
    • CommunityAnalytics
  • Communication & Context
    • CommunicationHub
    • SharedContextManager
  • Agent Adapters
    • AgentAdapter
    • StandardLLMAdapter
    • AgentAdapterRegistry
  • Builder
    • CommunityBuilder
  • 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
    • 3. AgentCommunicationMessage - Agent Communication Message Model
  • 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
    • 2. Troubleshooting
    • 3. Performance Optimization
    • 4. Data Migration
  • 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
    • 2. Conversation History Management
    • 3. Task Context Management
    • 4. Checkpoint Management
    • 5. Multi-Backend Storage Support
    • 6. Permanent Storage Dual-Write (Redis hot + cold archive)
    • 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
    • 2. Troubleshooting
    • 3. Performance Optimization
    • 4. 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
  • 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
    • 2. Troubleshooting
    • 3. Performance Optimization
    • 4. Data Migration
  • 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)
    • Downstream Components (Dependencies)
  • 4. Core Features and Use Cases
    • 4.1 TaskContext - Task Context Management
    • 4.2 DSLStep - DSL Step Definition
    • 4.3 Real-World Use Cases
  • 5. API Reference
    • 5.1 TaskContext Class
    • 5.2 DSLStep Class
  • 6. Technical Implementation Details
    • 6.1 Data Model Design
    • 6.2 Serialization Mechanism
    • 6.3 Type Safety Mechanism
  • 7. Configuration and Deployment
    • 7.1 Default Configuration
    • 7.2 Environment Variable Support
    • 7.3 Deployment Configuration
  • 8. Maintenance and Troubleshooting
    • 8.1 Daily Maintenance
    • 8.2 Troubleshooting
    • 8.3 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)
    • Downstream Components (Dependencies)
  • 4. Core Features and Use Cases
    • 4.1 TaskContext - Enhanced Task Context Management
    • 4.2 ContextUpdate - Context Update Model
    • 4.3 Software Functionality Scenarios
    • 4.4 Real-world Use Cases
  • 5. API Reference
    • 5.1 TaskContext Class
    • 5.2 ContextUpdate Class
    • 5.3 Utility Functions
  • 6. Technical Implementation Details
    • 6.1 Context History Management
    • 6.2 Resource Management Mechanism
    • 6.3 Context Optimization Mechanism
    • 6.4 Async Context Management
  • 7. Configuration and Deployment
    • 7.1 Default Configuration
    • 7.2 Environment Variable Support
    • 7.3 Deployment Configuration
  • 8. Maintenance and Troubleshooting
    • 8.1 Daily Maintenance
    • 8.2 Troubleshooting
    • 8.3 Performance 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
    • 2. Step Type Support
    • 3. Value Parsing and Comparison
    • 4. Async Execution Support
  • 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
    • 2. Troubleshooting
    • 3. Performance Optimization
    • 4. Extension Support
  • 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
  • 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.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
    • 4.2 User Notification and Interaction
    • 4.3 Real-Time Message Push
    • 4.4 Heartbeat Detection and Connection Management
    • 4.5 Client Message Handling
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Data Models
    • 5.3 Public Methods
  • 6. Technical Implementation Details
    • 6.1 Connection Management Mechanism
    • 6.2 Message Handling Mechanism
    • 6.3 Error Handling Strategy
    • 6.4 Concurrency Control Mechanism
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Docker Deployment
    • 7.3 Load Balancing Configuration
    • 7.4 Monitoring and Logging Configuration
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues & Solutions
    • 8.3 Performance Optimization Recommendations
  • 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
    • 4.2 DSL Task Step Execution
    • 4.3 Batch Task Processing
    • 4.4 Task Monitoring and Management
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Public Methods
  • 6. Technical Implementation Details
    • 6.1 Queue Management Strategy
    • 6.2 Task Type Auto-Detection
    • 6.3 Timeout Handling Mechanism
    • 6.4 Error Handling Strategy
    • 6.5 Batch Processing Optimization
  • 7. Configuration & Deployment
    • 7.1 Configuration Parameters
    • 7.2 Environment Variable Support
    • 7.3 Docker Deployment
    • 7.4 Production Environment Configuration
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues & Solutions
    • 8.3 Performance Optimization Recommendations
  • 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
    • 4.2 Database Operation Tracing
    • 4.3 External Service Call Tracing
    • 4.4 Tool Execution Tracing
    • 4.5 Cross-Service Tracing
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Public Methods
  • 6. Technical Implementation Details
    • 6.1 Jaeger Integration
    • 6.2 Decorator Implementation
    • 6.3 Context Propagation
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Docker Deployment
  • 8. Maintenance & Troubleshooting
    • 8.1 Common Issues & Solutions
  • 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
    • 4.2 Decorator Monitoring
    • 4.3 Comprehensive Operation Recording
    • 4.4 Custom Metrics Recording
    • 4.5 Metrics Query and Monitoring
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Public Methods
  • 6. Technical Implementation Details
    • 6.1 Prometheus Metric Types
    • 6.2 Decorator Implementation Mechanism
    • 6.3 Label Management Mechanism
    • 6.4 Error Handling Strategy
    • 6.5 Performance Optimization Mechanism
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Docker Deployment
    • 7.3 Prometheus Configuration
    • 7.4 Grafana Dashboard Configuration
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues & Solutions
    • 8.3 Performance Optimization Recommendations
  • 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
    • 5.2 Usage in Components
    • 5.3 Configuration Options
  • 6. Migration Guide
    • 6.1 Migrating from Independent ExecutorMetrics
    • 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
    • 8.2 Debugging Tips
  • 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
    • 4.2 Task History Management
    • 4.3 Task Status Management
    • 4.4 Data Maintenance and Cleanup
    • 4.5 Batch Operations
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Public Methods
  • 6. Technical Implementation Details
    • 6.1 Connection Pool Management
    • 6.2 Database Schema Management
    • 6.3 Error Handling Strategy
    • 6.4 Performance Optimization
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Docker Deployment
    • 7.3 Production Environment Configuration
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues & Solutions
  • 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
    • 4.2 File Retrieval and Management
    • 4.3 File Listing and Search
    • 4.4 File Deletion and Cleanup
    • 4.5 Task Result Storage
    • 4.6 Caching and Performance Optimization
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Public Methods
    • 5.3 Global Functions
  • 6. Technical Implementation Details
    • 6.1 Storage Backend Management
    • 6.2 Cache Management Mechanism
    • 6.3 Data Serialization and Compression
    • 6.4 Error Handling and Retry Mechanism
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Docker Deployment
    • 7.3 Production Environment Configuration
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues & Solutions
  • 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
    • 4.2 Task Status Caching
    • 4.3 User Session Management
    • 4.4 Distributed Lock Implementation
    • 4.5 Cache Strategy Implementation
  • 5. API Reference
    • 5.1 Class Definition
    • 5.2 Public Methods
    • 5.3 Global Functions
  • 6. Technical Implementation Details
    • 6.1 Connection Pool Management
    • 6.2 Singleton Pattern Implementation
    • 6.3 Error Handling Strategy
    • 6.4 Connection Health Check
  • 7. Configuration & Deployment
    • 7.1 Basic Configuration
    • 7.2 Docker Deployment
    • 7.3 Production Environment Configuration
  • 8. Maintenance & Troubleshooting
    • 8.1 Monitoring Metrics
    • 8.2 Common Issues & Solutions
  • 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
    • 2. Data Serialization Standards
    • 3. Performance Optimization Standards
  • Usage Examples
    • 1. Basic Storage Implementation
    • 2. Storage Factory Pattern
    • 3. Storage Adapter Pattern
  • Maintenance Guide
    • 1. Daily Maintenance
    • 2. Troubleshooting
    • 3. Performance 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
    • 2. Error Handling Standards
    • 3. Logging and Monitoring Standards
  • Usage Examples
    • 1. Basic Interface Implementation
    • 2. Cache Provider Implementation
    • 3. Operation Executor Implementation
  • Maintenance Guide
    • 1. Daily Maintenance
    • 2. Troubleshooting
    • 3. Interface Updates
    • 4. Interface Extension
  • 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
    • 2. Troubleshooting
    • 3. Configuration Updates
    • 4. Configuration Extension
  • 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
    • Infrastructure Configuration
    • Cloud Service Configuration
  • Configuration Management Best Practices
    • 1. Environment Variable Management
    • 2. Configuration Validation Strategy
    • 3. Configuration Security
    • 4. Configuration Monitoring
  • Maintenance Guide
    • 1. Daily Maintenance
    • 2. Troubleshooting
    • 3. Configuration Updates
    • 4. Configuration Extension
  • 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
    • 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
    • Utility Methods
  • Configuration Management
    • Default Configuration
    • Environment Variable Support
  • Error Handling
    • Exception Types & Examples
    • Error Code Mapping
    • Error Recovery Strategies
    • 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
    • 5.2 Convenience Functions
  • 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.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
• 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
  • 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.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
• 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
    • 5.2 Global Instance
  • 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.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
• 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
  • 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.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
• 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
  • 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.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

API Reference

• Core API
  • Core Interfaces
• Domain API
  • Agent
  • Context
  • Task
• Application API
  • Application Executors
  • Knowledge Graph
• Infrastructure API
  • Persistence
  • Monitoring
  • Messaging
• Tools API
  • Tool Configuration
  • Base Tool
  • Document Tools
  • Search Tool
  • API Source Tool
• LLM API
  • Client Factory
  • LLM Clients
  • Configuration

Development

• Changelog

Indices and tables

• Index

• Module Index

• Search Page