Skip to content

Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.

Add docs redirects and development tools (#3096)

Tony Kipkemboi640e1a7bc26e
diff --git a/.cursorrules b/.cursorrules
new file mode 100644
index 000000000..4278244db
--- /dev/null
+++ b/.cursorrules
@@ -0,0 +1,1429 @@
+# CrewAI Development Rules
+# Comprehensive best practices for developing with the CrewAI library, covering code organization, performance, security, testing, and common patterns. Based on actual CrewAI codebase analysis for accuracy.
+
+## General Best Practices:
+- Leverage structured responses from LLM calls using Pydantic BaseModel for output validation.
+- Use the @CrewBase decorator pattern with @agent, @task, and @crew decorators for proper organization.
+- Regularly validate outputs from agents and tasks using built-in guardrails or custom validation.
+- Use UV for dependency management (CrewAI's standard) with pyproject.toml configuration.
+- Python version requirements: 3.10 to 3.14 (as per CrewAI's pyproject.toml).
+- Prefer declarative YAML configuration for agents and tasks over hardcoded definitions.
+
+## Code Organization and Structure:
+- **Standard CrewAI Project Structure** (from CLI templates):
+ - `project_name/` (Root directory)
+ - `.env` (Environment variables - never commit API keys)
+ - `pyproject.toml` (UV-based dependency management)
+ - `knowledge/` (Knowledge base files)
+ - `src/project_name/`
+ - `__init__.py`
+ - `main.py` (Entry point)
+ - `crew.py` (Crew orchestration with @CrewBase decorator)
+ - `config/`
+ - `agents.yaml` (Agent definitions)
+ - `tasks.yaml` (Task definitions)
+ - `tools/`
+ - `custom_tool.py` (Custom agent tools)
+ - `__init__.py`
+- **File Naming Conventions**:
+ - Use descriptive, lowercase names with underscores (e.g., `research_agent.py`).
+ - Pydantic models: singular names (e.g., `article_summary.py` with class `ArticleSummary`).
+ - Tests: mirror source file name with `_test` suffix (e.g., `crew_test.py`).
+- **CrewAI Class Architecture**:
+ - Use @CrewBase decorator for main crew class.
+ - Define agents with @agent decorator returning Agent instances.
+ - Define tasks with @task decorator returning Task instances.
+ - Define crew orchestration with @crew decorator returning Crew instance.
+ - Access configuration via `self.agents_config` and `self.tasks_config`.
+
+## Memory System Patterns:
+- **Memory Types** (all supported by CrewAI):
+ - Short-term memory: ChromaDB with RAG for current context
+ - Long-term memory: SQLite for task results across sessions
+ - Entity memory: RAG to track entities (people, places, concepts)
+ - External memory: Mem0 integration for advanced memory features
+- **Memory Configuration**:
+ - Enable basic memory: `Crew(..., memory=True)`
+ - Custom storage location: Set `CREWAI_STORAGE_DIR` environment variable
+ - Memory is stored in platform-specific directories via `appdirs` by default
+- **Memory Usage**:
+ - Memory is automatically managed by agents during task execution
+ - Access via agent's memory attribute for custom implementations
+ - Use metadata for categorizing and filtering memory entries
+
+## Pydantic Integration Patterns:
+- **Structured Outputs**:
+ - Use `output_pydantic` in Task definitions for structured results
+ - Use `output_json` for JSON dictionary outputs
+ - Cannot use both output_pydantic and output_json simultaneously
+- **Task Output Handling**:
+ - TaskOutput contains raw, pydantic, and json_dict attributes
+ - CrewOutput aggregates all task outputs with token usage metrics
+ - Use model_validate_json for Pydantic model validation
+- **Custom Models**:
+ - Inherit from BaseModel for all data structures
+ - Use Field descriptions for LLM understanding
+ - Implement model_validator for custom validation logic
+
+## YAML Configuration Best Practices:
+- **agents.yaml Structure**:
+ ```yaml
+ agent_name:
+ role: "Clear, specific role description"
+ goal: "Specific goal statement"
+ backstory: "Detailed background for context"
+ # Optional: tools, llm, memory, etc.
+ ```
+- **tasks.yaml Structure**:
+ ```yaml
+ task_name:
+ description: "Detailed task description with context"
+ expected_output: "Clear output format specification"
+ agent: agent_name # Reference to agent in agents.yaml
+ # Optional: context, tools, output_file, etc.
+ ```
+- **Configuration Access**:
+ - Use `self.agents_config['agent_name']` in @agent methods
+ - Use `self.tasks_config['task_name']` in @task methods
+ - Support for dynamic configuration via placeholders like {topic}
+
+## Tools and Integration Patterns:
+- **Custom Tools**:
+ - Inherit from BaseTool for custom tool implementation
+ - Use @tool decorator for simple tool definitions
+ - Implement proper error handling and input validation
+- **Tool Integration**:
+ - Add tools to agents via tools parameter in Agent constructor
+ - Tools are automatically inherited by tasks from their assigned agents
+ - Use structured tool outputs for better LLM understanding
+
+## Performance Considerations:
+- **LLM Optimization**:
+ - Use task context to pass information between sequential tasks
+ - Implement output caching to avoid redundant LLM calls
+ - Configure appropriate LLM models per agent for cost/performance balance
+- **Memory Management**:
+ - Be mindful of memory storage growth in long-running applications
+ - Use score_threshold in memory search to filter relevant results
+ - Implement periodic memory cleanup if needed
+- **Async Operations**:
+ - Use execute_sync for synchronous task execution
+ - Consider async patterns for I/O-bound operations in custom tools
+
+## Security Best Practices:
+- **API Key Management**:
+ - Always use .env files for API keys and sensitive configuration
+ - Never commit API keys to version control
+ - Use environment variables in production deployments
+- **Input Validation**:
+ - Validate all inputs using Pydantic models where possible
+ - Implement guardrails for task output validation
+ - Use field_validator for custom validation logic
+- **Tool Security**:
+ - Implement proper access controls in custom tools
+ - Validate tool inputs and outputs
+ - Follow principle of least privilege for tool permissions
+
+## Testing Approaches:
+- **Unit Testing**:
+ - Test individual agents, tasks, and tools in isolation
+ - Use mocking for external dependencies (LLMs, APIs)
+ - Test configuration loading and validation
+- **Integration Testing**:
+ - Test crew execution end-to-end with realistic scenarios
+ - Verify memory persistence across crew runs
+ - Test tool integration and data flow between tasks
+- **Test Organization**:
+ - Follow CrewAI's test structure: separate test files for each component
+ - Use pytest fixtures for common test setup
+ - Mock LLM responses for consistent, fast tests
+
+## Common CrewAI Patterns and Anti-patterns:
+- **Recommended Patterns**:
+ - Use sequential Process for dependent tasks, hierarchical for manager delegation
+ - Implement task context for data flow between tasks
+ - Use output_file for persistent task results
+ - Leverage crew callbacks with @before_kickoff and @after_kickoff decorators
+- **Anti-patterns to Avoid**:
+ - Don't hardcode agent configurations in Python code (use YAML)
+ - Don't create circular task dependencies
+ - Don't ignore task execution failures without proper error handling
+ - Don't overload single agents with too many diverse tools
+- **Error Handling**:
+ - Implement task-level guardrails for output validation
+ - Use try-catch blocks in custom tools
+ - Set appropriate max_retries for tasks prone to failures
+ - Log errors with sufficient context for debugging
+
+## Development Workflow:
+- **UV Commands**:
+ - `crewai create crew <name>` - Create new crew project
+ - `crewai install` - Install dependencies via UV
+ - `crewai run` - Execute the crew
+ - `uv sync` - Sync dependencies
+ - `uv add <package>` - Add new dependencies
+- **Project Setup**:
+ - Use CrewAI CLI for project scaffolding
+ - Follow the standard directory structure
+ - Configure agents and tasks in YAML before implementing crew logic
+- **Development Tools**:
+ - Use UV for dependency management (CrewAI standard)
+ - Configure pre-commit hooks for code quality
+ - Use pytest for testing with CrewAI's testing patterns
+
+## Deployment and Production:
+- **Environment Configuration**:
+ - Set CREWAI_STORAGE_DIR for controlled memory storage location
+ - Use proper logging configuration for production monitoring
+ - Configure appropriate LLM providers and rate limits
+- **Containerization**:
+ - Include knowledge and config directories in Docker images
+ - Mount memory storage as persistent volumes if needed
+ - Set proper environment variables for API keys and configuration
+- **Monitoring**:
+ - Monitor token usage via CrewOutput.token_usage
+ - Track task execution times and success rates
+ - Implement health checks for long-running crew services
+
+## CrewAI Flow Patterns and Best Practices
+
+### Flow Architecture and Structure
+- **Use Flow class** for complex multi-step workflows that go beyond simple crew orchestration
+- **Combine Flows with Crews** to create sophisticated AI automation pipelines
+- **Leverage state management** to share data between flow methods
+- **Event-driven design** allows for dynamic and responsive workflow execution
+
+### Flow Decorators and Control Flow
+- **@start()**: Mark entry points for flow execution (can have multiple start methods)
+- **@listen()**: Create method dependencies and execution chains
+- **@router()**: Implement conditional branching based on method outputs
+- **or_()** and **and_()**: Combine multiple trigger conditions for complex workflows
+
+### Flow State Management Patterns
+```python
+# Structured state with Pydantic (recommended for complex workflows)
+class WorkflowState(BaseModel):
+ task_results: List[str] = []
+ current_step: str = "initialize"
+ user_preferences: dict = {}
+ completion_status: bool = False
+
+class MyFlow(Flow[WorkflowState]):
+ @start()
+ def initialize(self):
+ self.state.current_step = "processing"
+ # State automatically gets unique UUID in self.state.id
+
+# Unstructured state (good for simple workflows)
+class SimpleFlow(Flow):
+ @start()
+ def begin(self):
+ self.state["counter"] = 0
+ self.state["results"] = []
+ # Auto-generated ID available in self.state["id"]
+```
+
+### Flow Method Patterns
+```python
+# Basic sequential flow
+@start()
+def step_one(self):
+ return "data from step one"
+
+@listen(step_one)
+def step_two(self, data_from_step_one):
+ return f"processed: {data_from_step_one}"
+
+# Parallel execution with convergence
+@start()
+def task_a(self):
+ return "result_a"
+
+@start()
+def task_b(self):
+ return "result_b"
+
+@listen(and_(task_a, task_b))
+def combine_results(self):
+ # Waits for both task_a AND task_b to complete
+ return f"combined: {self.state}"
+
+# Conditional routing
+@router(step_one)
+def decision_point(self):
+ if some_condition:
+ return "success_path"
+ return "failure_path"
+
+@listen("success_path")
+def handle_success(self):
+ # Handle success case
+ pass
+
+@listen("failure_path")
+def handle_failure(self):
+ # Handle failure case
+ pass
+
+# OR condition listening
+@listen(or_(task_a, task_b))
+def process_any_result(self, result):
+ # Triggers when EITHER task_a OR task_b completes
+ return f"got result: {result}"
+```
+
+### Flow Persistence Patterns
+```python
+# Class-level persistence (all methods persisted)
+@persist(verbose=True)
+class PersistentFlow(Flow[MyState]):
+ @start()
+ def initialize(self):
+ self.state.counter += 1
+
+# Method-level persistence (selective)
+class SelectiveFlow(Flow):
+ @persist
+ @start()
+ def critical_step(self):
+ # Only this method's state is persisted
+ self.state["important_data"] = "value"
+
+ @start()
+ def temporary_step(self):
+ # This method's state is not persisted
+ pass
+```
+
+### Flow Execution Patterns
+```python
+# Synchronous execution
+flow = MyFlow()
+result = flow.kickoff()
+final_state = flow.state
+
+# Asynchronous execution
+async def run_async_flow():
+ flow = MyFlow()
+ result = await flow.kickoff_async()
+ return result
+
+# Flow with input parameters
+flow = MyFlow()
+result = flow.kickoff(inputs={"user_id": "123", "task": "research"})
+
+# Flow plotting and visualization
+flow.plot("workflow_diagram") # Generates HTML visualization
+```
+
+### Advanced Flow Patterns
+```python
+# Cyclic/Loop patterns
+class CyclicFlow(Flow):
+ max_iterations = 5
+ current_iteration = 0
+
+ @start("loop")
+ def process_iteration(self):
+ if self.current_iteration >= self.max_iterations:
+ return
+ # Process current iteration
+ self.current_iteration += 1
+
+ @router(process_iteration)
+ def check_continue(self):
+ if self.current_iteration < self.max_iterations:
+ return "loop" # Continue cycling
+ return "complete"
+
+ @listen("complete")
+ def finalize(self):
+ # Final processing
+ pass
+
+# Complex multi-router pattern
+@router(analyze_data)
+def primary_router(self):
+ # Returns multiple possible paths based on analysis
+ if self.state.confidence > 0.8:
+ return "high_confidence"
+ elif self.state.errors_found:
+ return "error_handling"
+ return "manual_review"
+
+@router("high_confidence")
+def secondary_router(self):
+ # Further routing based on high confidence results
+ return "automated_processing"
+
+# Exception handling in flows
+@start()
+def risky_operation(self):
+ try:
+ # Some operation that might fail
+ result = dangerous_function()
+ self.state["success"] = True
+ return result
+ except Exception as e:
+ self.state["error"] = str(e)
+ self.state["success"] = False
+ return None
+
+@listen(risky_operation)
+def handle_result(self, result):
+ if self.state.get("success", False):
+ # Handle success case
+ pass
+ else:
+ # Handle error case
+ error = self.state.get("error")
+ # Implement error recovery logic
+```
+
+### Flow Integration with Crews
+```python
+# Combining Flows with Crews for complex workflows
+class CrewOrchestrationFlow(Flow[WorkflowState]):
+ @start()
+ def research_phase(self):
+ research_crew = ResearchCrew()
+ result = research_crew.crew().kickoff(inputs={"topic": self.state.research_topic})
+ self.state.research_results = result.raw
+ return result
+
+ @listen(research_phase)
+ def analysis_phase(self, research_results):
+ analysis_crew = AnalysisCrew()
+ result = analysis_crew.crew().kickoff(inputs={
+ "data": self.state.research_results,
+ "focus": self.state.analysis_focus
+ })
+ self.state.analysis_results = result.raw
+ return result
+
+ @router(analysis_phase)
+ def decide_next_action(self):
+ if self.state.analysis_results.confidence > 0.7:
+ return "generate_report"
+ return "additional_research"
+
+ @listen("generate_report")
+ def final_report(self):
+ reporting_crew = ReportingCrew()
+ return reporting_crew.crew().kickoff(inputs={
+ "research": self.state.research_results,
+ "analysis": self.state.analysis_results
+ })
+```
+
+### Flow Best Practices
+- **State Management**: Use structured state (Pydantic) for complex workflows, unstructured for simple ones
+- **Method Design**: Keep flow methods focused and single-purpose
+- **Error Handling**: Implement proper exception handling and error recovery paths
+- **State Persistence**: Use @persist for critical workflows that need recovery capability
+- **Flow Visualization**: Use flow.plot() to understand and debug complex workflow structures
+- **Async Support**: Leverage async methods for I/O-bound operations within flows
+- **Resource Management**: Be mindful of state size and memory usage in long-running flows
+- **Testing Flows**: Test individual methods and overall flow execution patterns
+- **Event Monitoring**: Use CrewAI event system to monitor flow execution and performance
+
+### Flow Anti-patterns to Avoid
+- **Don't create overly complex flows** with too many branches and conditions
+- **Don't store large objects** in state that could cause memory issues
+- **Don't ignore error handling** in flow methods
+- **Don't create circular dependencies** between flow methods
+- **Don't mix synchronous and asynchronous** patterns inconsistently
+- **Don't overuse routers** when simple linear flow would suffice
+- **Don't forget to handle edge cases** in router logic
+
+## CrewAI Version Compatibility:
+- Stay updated with CrewAI releases for new features and bug fixes
+- Test crew functionality when upgrading CrewAI versions
+- Use version constraints in pyproject.toml (e.g., "crewai[tools]>=0.134.0,<1.0.0")
+- Monitor deprecation warnings for future compatibility
+
+## Code Examples and Implementation Patterns
+
+### Complete Crew Implementation Example:
+```python
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task, before_kickoff, after_kickoff
+from crewai_tools import SerperDevTool, FileReadTool
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+from pydantic import BaseModel, Field
+
+class ResearchOutput(BaseModel):
+ title: str = Field(description="Research topic title")
+ summary: str = Field(description="Executive summary")
+ key_findings: List[str] = Field(description="Key research findings")
+ recommendations: List[str] = Field(description="Actionable recommendations")
+ sources: List[str] = Field(description="Source URLs and references")
+ confidence_score: float = Field(description="Confidence in findings (0-1)")
+
+@CrewBase
+class ResearchCrew():
+ """Advanced research crew with structured outputs and validation"""
+
+ agents: List[BaseAgent]
+ tasks: List[Task]
+
+ @before_kickoff
+ def setup_environment(self):
+ """Initialize environment before crew execution"""
+ print("🚀 Setting up research environment...")
+ # Validate API keys, create directories, etc.
+
+ @after_kickoff
+ def cleanup_and_report(self, output):
+ """Handle post-execution tasks"""
+ print(f"✅ Research completed. Generated {len(output.tasks_output)} task outputs")
+ print(f"📊 Token usage: {output.token_usage}")
+
+ @agent
+ def researcher(self) -> Agent:
+ return Agent(
+ config=self.agents_config['researcher'],
+ tools=[SerperDevTool()],
+ verbose=True,
+ memory=True,
+ max_iter=15,
+ max_execution_time=1800
+ )
+
+ @agent
+ def analyst(self) -> Agent:
+ return Agent(
+ config=self.agents_config['analyst'],
+ tools=[FileReadTool()],
+ verbose=True,
+ memory=True
+ )
+
+ @task
+ def research_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['research_task'],
+ agent=self.researcher(),
+ output_pydantic=ResearchOutput
+ )
+
+ @task
+ def validation_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['validation_task'],
+ agent=self.analyst(),
+ context=[self.research_task()],
+ guardrail=self.validate_research_quality,
+ max_retries=3
+ )
+
+ def validate_research_quality(self, output) -> tuple[bool, str]:
+ """Custom guardrail to ensure research quality"""
+ content = output.raw
+ if len(content) < 500:
+ return False, "Research output too brief. Need more detailed analysis."
+ if not any(keyword in content.lower() for keyword in ['conclusion', 'finding', 'result']):
+ return False, "Missing key analytical elements."
+ return True, content
+
+ @crew
+ def crew(self) -> Crew:
+ return Crew(
+ agents=self.agents,
+ tasks=self.tasks,
+ process=Process.sequential,
+ memory=True,
+ verbose=True,
+ max_rpm=100
+ )
+```
+
+### Custom Tool Implementation with Error Handling:
+```python
+from crewai.tools import BaseTool
+from typing import Type, Optional, Any
+from pydantic import BaseModel, Field
+import requests
+import time
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+class SearchInput(BaseModel):
+ query: str = Field(description="Search query")
+ max_results: int = Field(default=10, description="Maximum results to return")
+ timeout: int = Field(default=30, description="Request timeout in seconds")
+
+class RobustSearchTool(BaseTool):
+ name: str = "robust_search"
+ description: str = "Perform web search with retry logic and error handling"
+ args_schema: Type[BaseModel] = SearchInput
+
+ def __init__(self, api_key: Optional[str] = None, **kwargs):
+ super().__init__(**kwargs)
+ self.api_key = api_key or os.getenv("SEARCH_API_KEY")
+ self.rate_limit_delay = 1.0
+ self.last_request_time = 0
+
+ @retry(
+ stop=stop_after_attempt(3),
+ wait=wait_exponential(multiplier=1, min=4, max=10)
+ )
+ def _run(self, query: str, max_results: int = 10, timeout: int = 30) -> str:
+ """Execute search with retry logic"""
+ try:
+ # Rate limiting
+ time_since_last = time.time() - self.last_request_time
+ if time_since_last < self.rate_limit_delay:
+ time.sleep(self.rate_limit_delay - time_since_last)
+
+ # Input validation
+ if not query or len(query.strip()) == 0:
+ return "Error: Empty search query provided"
+
+ if len(query) > 500:
+ return "Error: Search query too long (max 500 characters)"
+
+ # Perform search
+ results = self._perform_search(query, max_results, timeout)
+ self.last_request_time = time.time()
+
+ return self._format_results(results)
+
+ except requests.exceptions.Timeout:
+ return f"Search timed out after {timeout} seconds"
+ except requests.exceptions.RequestException as e:
+ return f"Search failed due to network error: {str(e)}"
+ except Exception as e:
+ return f"Unexpected error during search: {str(e)}"
+
+ def _perform_search(self, query: str, max_results: int, timeout: int) -> List[dict]:
+ """Implement actual search logic here"""
+ # Your search API implementation
+ pass
+
+ def _format_results(self, results: List[dict]) -> str:
+ """Format search results for LLM consumption"""
+ if not results:
+ return "No results found for the given query."
+
+ formatted = "Search Results:\n\n"
+ for i, result in enumerate(results[:10], 1):
+ formatted += f"{i}. {result.get('title', 'No title')}\n"
+ formatted += f" URL: {result.get('url', 'No URL')}\n"
+ formatted += f" Summary: {result.get('snippet', 'No summary')}\n\n"
+
+ return formatted
+```
+
+### Advanced Memory Management:
+```python
+import os
+from crewai.memory import ExternalMemory, ShortTermMemory, LongTermMemory
+from crewai.memory.storage.mem0_storage import Mem0Storage
+
+class AdvancedMemoryManager:
+ """Enhanced memory management for CrewAI applications"""
+
+ def __init__(self, crew, config: dict = None):
+ self.crew = crew
+ self.config = config or {}
+ self.setup_memory_systems()
+
+ def setup_memory_systems(self):
+ """Configure multiple memory systems"""
+ # Short-term memory for current session
+ self.short_term = ShortTermMemory()
+
+ # Long-term memory for cross-session persistence
+ self.long_term = LongTermMemory()
+
+ # External memory with Mem0 (if configured)
+ if self.config.get('use_external_memory'):
+ self.external = ExternalMemory.create_storage(
+ crew=self.crew,
+ embedder_config={
+ "provider": "mem0",
+ "config": {
+ "api_key": os.getenv("MEM0_API_KEY"),
+ "user_id": self.config.get('user_id', 'default')
+ }
+ }
+ )
+
+ def save_with_context(self, content: str, memory_type: str = "short_term",
+ metadata: dict = None, agent: str = None):
+ """Save content with enhanced metadata"""
+ enhanced_metadata = {
+ "timestamp": time.time(),
+ "session_id": self.config.get('session_id'),
+ "crew_type": self.crew.__class__.__name__,
+ **(metadata or {})
+ }
+
+ if memory_type == "short_term":
+ self.short_term.save(content, enhanced_metadata, agent)
+ elif memory_type == "long_term":
+ self.long_term.save(content, enhanced_metadata, agent)
+ elif memory_type == "external" and hasattr(self, 'external'):
+ self.external.save(content, enhanced_metadata, agent)
+
+ def search_across_memories(self, query: str, limit: int = 5) -> dict:
+ """Search across all memory systems"""
+ results = {
+ "short_term": [],
+ "long_term": [],
+ "external": []
+ }
+
+ # Search short-term memory
+ results["short_term"] = self.short_term.search(query, limit=limit)
+
+ # Search long-term memory
+ results["long_term"] = self.long_term.search(query, limit=limit)
+
+ # Search external memory (if available)
+ if hasattr(self, 'external'):
+ results["external"] = self.external.search(query, limit=limit)
+
+ return results
+
+ def cleanup_old_memories(self, days_threshold: int = 30):
+ """Clean up old memories based on age"""
+ cutoff_time = time.time() - (days_threshold * 24 * 60 * 60)
+
+ # Implement cleanup logic based on timestamps in metadata
+ # This would vary based on your specific storage implementation
+ pass
+```
+
+### Production Monitoring and Metrics:
+```python
+import time
+import logging
+import json
+from datetime import datetime
+from typing import Dict, Any, List
+from dataclasses import dataclass, asdict
+
+@dataclass
+class TaskMetrics:
+ task_name: str
+ agent_name: str
+ start_time: float
+ end_time: float
+ duration: float
+ tokens_used: int
+ success: bool
+ error_message: Optional[str] = None
+ memory_usage_mb: Optional[float] = None
+
+class CrewMonitor:
+ """Comprehensive monitoring for CrewAI applications"""
+
+ def __init__(self, crew_name: str, log_level: str = "INFO"):
+ self.crew_name = crew_name
+ self.metrics: List[TaskMetrics] = []
+ self.session_start = time.time()
+
+ # Setup logging
+ logging.basicConfig(
+ level=getattr(logging, log_level),
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[
+ logging.FileHandler(f'crew_{crew_name}_{datetime.now().strftime("%Y%m%d")}.log'),
+ logging.StreamHandler()
+ ]
+ )
+ self.logger = logging.getLogger(f"CrewAI.{crew_name}")
+
+ def start_task_monitoring(self, task_name: str, agent_name: str) -> dict:
+ """Start monitoring a task execution"""
+ context = {
+ "task_name": task_name,
+ "agent_name": agent_name,
+ "start_time": time.time()
+ }
+
+ self.logger.info(f"Task started: {task_name} by {agent_name}")
+ return context
+
+ def end_task_monitoring(self, context: dict, success: bool = True,
+ tokens_used: int = 0, error: str = None):
+ """End monitoring and record metrics"""
+ end_time = time.time()
+ duration = end_time - context["start_time"]
+
+ # Get memory usage (if psutil is available)
+ memory_usage = None
+ try:
+ import psutil
+ process = psutil.Process()
+ memory_usage = process.memory_info().rss / 1024 / 1024 # MB
+ except ImportError:
+ pass
+
+ metrics = TaskMetrics(
+ task_name=context["task_name"],
+ agent_name=context["agent_name"],
+ start_time=context["start_time"],
+ end_time=end_time,
+ duration=duration,
+ tokens_used=tokens_used,
+ success=success,
+ error_message=error,
+ memory_usage_mb=memory_usage
+ )
+
+ self.metrics.append(metrics)
+
+ # Log the completion
+ status = "SUCCESS" if success else "FAILED"
+ self.logger.info(f"Task {status}: {context['task_name']} "
+ f"(Duration: {duration:.2f}s, Tokens: {tokens_used})")
+
+ if error:
+ self.logger.error(f"Task error: {error}")
+
+ def get_performance_summary(self) -> Dict[str, Any]:
+ """Generate comprehensive performance summary"""
+ if not self.metrics:
+ return {"message": "No metrics recorded yet"}
+
+ successful_tasks = [m for m in self.metrics if m.success]
+ failed_tasks = [m for m in self.metrics if not m.success]
+
+ total_duration = sum(m.duration for m in self.metrics)
+ total_tokens = sum(m.tokens_used for m in self.metrics)
+ avg_duration = total_duration / len(self.metrics)
+
+ return {
+ "crew_name": self.crew_name,
+ "session_duration": time.time() - self.session_start,
+ "total_tasks": len(self.metrics),
+ "successful_tasks": len(successful_tasks),
+ "failed_tasks": len(failed_tasks),
+ "success_rate": len(successful_tasks) / len(self.metrics),
+ "total_duration": total_duration,
+ "average_task_duration": avg_duration,
+ "total_tokens_used": total_tokens,
+ "average_tokens_per_task": total_tokens / len(self.metrics) if self.metrics else 0,
+ "slowest_task": max(self.metrics, key=lambda x: x.duration).task_name if self.metrics else None,
+ "most_token_intensive": max(self.metrics, key=lambda x: x.tokens_used).task_name if self.metrics else None,
+ "common_errors": self._get_common_errors()
+ }
+
+ def _get_common_errors(self) -> Dict[str, int]:
+ """Get frequency of common errors"""
+ error_counts = {}
+ for metric in self.metrics:
+ if metric.error_message:
+ error_counts[metric.error_message] = error_counts.get(metric.error_message, 0) + 1
+ return dict(sorted(error_counts.items(), key=lambda x: x[1], reverse=True))
+
+ def export_metrics(self, filename: str = None) -> str:
+ """Export metrics to JSON file"""
+ if not filename:
+ filename = f"crew_metrics_{self.crew_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+
+ export_data = {
+ "summary": self.get_performance_summary(),
+ "detailed_metrics": [asdict(m) for m in self.metrics]
+ }
+
+ with open(filename, 'w') as f:
+ json.dump(export_data, f, indent=2, default=str)
+
+ self.logger.info(f"Metrics exported to {filename}")
+ return filename
+
+# Usage in crew implementation
+monitor = CrewMonitor("research_crew")
+
+@task
+def monitored_research_task(self) -> Task:
+ def task_callback(task_output):
+ # This would be called after task completion
+ context = getattr(task_output, '_monitor_context', {})
+ if context:
+ tokens = getattr(task_output, 'token_usage', {}).get('total', 0)
+ monitor.end_task_monitoring(context, success=True, tokens_used=tokens)
+
+ # Start monitoring would be called before task execution
+ # This is a simplified example - in practice you'd integrate this into the task execution flow
+
+ return Task(
+ config=self.tasks_config['research_task'],
+ agent=self.researcher(),
+ callback=task_callback
+ )
+```
+
+### Error Handling and Recovery Patterns:
+```python
+from enum import Enum
+from typing import Optional, Callable, Any
+import traceback
+
+class ErrorSeverity(Enum):
+ LOW = "low"
+ MEDIUM = "medium"
+ HIGH = "high"
+ CRITICAL = "critical"
+
+class CrewError(Exception):
+ """Base exception for CrewAI applications"""
+ def __init__(self, message: str, severity: ErrorSeverity = ErrorSeverity.MEDIUM,
+ context: dict = None):
+ super().__init__(message)
+ self.severity = severity
+ self.context = context or {}
+ self.timestamp = time.time()
+
+class TaskExecutionError(CrewError):
+ """Raised when task execution fails"""
+ pass
+
+class ValidationError(CrewError):
+ """Raised when validation fails"""
+ pass
+
+class ConfigurationError(CrewError):
+ """Raised when configuration is invalid"""
+ pass
+
+class ErrorHandler:
+ """Centralized error handling for CrewAI applications"""
+
+ def __init__(self, crew_name: str):
+ self.crew_name = crew_name
+ self.error_log: List[CrewError] = []
+ self.recovery_strategies: Dict[type, Callable] = {}
+
+ def register_recovery_strategy(self, error_type: type, strategy: Callable):
+ """Register a recovery strategy for specific error types"""
+ self.recovery_strategies[error_type] = strategy
+
+ def handle_error(self, error: Exception, context: dict = None) -> Any:
+ """Handle errors with appropriate recovery strategies"""
+
+ # Convert to CrewError if needed
+ if not isinstance(error, CrewError):
+ crew_error = CrewError(
+ message=str(error),
+ severity=ErrorSeverity.MEDIUM,
+ context=context or {}
+ )
+ else:
+ crew_error = error
+
+ # Log the error
+ self.error_log.append(crew_error)
+ self._log_error(crew_error)
+
+ # Apply recovery strategy if available
+ error_type = type(error)
+ if error_type in self.recovery_strategies:
+ try:
+ return self.recovery_strategies[error_type](error, context)
+ except Exception as recovery_error:
+ self._log_error(CrewError(
+ f"Recovery strategy failed: {str(recovery_error)}",
+ ErrorSeverity.HIGH,
+ {"original_error": str(error), "recovery_error": str(recovery_error)}
+ ))
+
+ # If critical, re-raise
+ if crew_error.severity == ErrorSeverity.CRITICAL:
+ raise crew_error
+
+ return None
+
+ def _log_error(self, error: CrewError):
+ """Log error with appropriate level based on severity"""
+ logger = logging.getLogger(f"CrewAI.{self.crew_name}.ErrorHandler")
+
+ error_msg = f"[{error.severity.value.upper()}] {error}"
+ if error.context:
+ error_msg += f" | Context: {error.context}"
+
+ if error.severity in [ErrorSeverity.HIGH, ErrorSeverity.CRITICAL]:
+ logger.error(error_msg)
+ logger.error(f"Stack trace: {traceback.format_exc()}")
+ elif error.severity == ErrorSeverity.MEDIUM:
+ logger.warning(error_msg)
+ else:
+ logger.info(error_msg)
+
+ def get_error_summary(self) -> Dict[str, Any]:
+ """Get summary of errors encountered"""
+ if not self.error_log:
+ return {"total_errors": 0}
+
+ severity_counts = {}
+ for error in self.error_log:
+ severity_counts[error.severity.value] = severity_counts.get(error.severity.value, 0) + 1
+
+ return {
+ "total_errors": len(self.error_log),
+ "severity_breakdown": severity_counts,
+ "recent_errors": [str(e) for e in self.error_log[-5:]], # Last 5 errors
+ "most_recent_error": str(self.error_log[-1]) if self.error_log else None
+ }
+
+# Example usage in crew
+error_handler = ErrorHandler("research_crew")
+
+# Register recovery strategies
+def retry_with_simpler_model(error, context):
+ """Recovery strategy: retry with a simpler model"""
+ if "rate limit" in str(error).lower():
+ time.sleep(60) # Wait and retry
+ return "RETRY"
+ elif "model overloaded" in str(error).lower():
+ # Switch to simpler model and retry
+ return "RETRY_WITH_SIMPLE_MODEL"
+ return None
+
+error_handler.register_recovery_strategy(TaskExecutionError, retry_with_simpler_model)
+
+@task
+def robust_task(self) -> Task:
+ def execute_with_error_handling(task_func):
+ def wrapper(*args, **kwargs):
+ try:
+ return task_func(*args, **kwargs)
+ except Exception as e:
+ result = error_handler.handle_error(e, {"task": "research_task"})
+ if result == "RETRY":
+ # Implement retry logic
+ pass
+ elif result == "RETRY_WITH_SIMPLE_MODEL":
+ # Switch model and retry
+ pass
+ else:
+ # Use fallback response
+ return "Task failed, using fallback response"
+ return wrapper
+
+ return Task(
+ config=self.tasks_config['research_task'],
+ agent=self.researcher()
+ )
+```
+
+### Environment and Configuration Management:
+```python
+import os
+from enum import Enum
+from typing import Optional, Dict, Any
+from pydantic import BaseSettings, Field, validator
+
+class Environment(str, Enum):
+ DEVELOPMENT = "development"
+ TESTING = "testing"
+ STAGING = "staging"
+ PRODUCTION = "production"
+
+class CrewAISettings(BaseSettings):
+ """Comprehensive settings management for CrewAI applications"""
+
+ # Environment
+ environment: Environment = Field(default=Environment.DEVELOPMENT)
+ debug: bool = Field(default=True)
+
+ # API Keys (loaded from environment)
+ openai_api_key: Optional[str] = Field(default=None, env="OPENAI_API_KEY")
+ anthropic_api_key: Optional[str] = Field(default=None, env="ANTHROPIC_API_KEY")
+ serper_api_key: Optional[str] = Field(default=None, env="SERPER_API_KEY")
+ mem0_api_key: Optional[str] = Field(default=None, env="MEM0_API_KEY")
+
+ # CrewAI Configuration
+ crew_max_rpm: int = Field(default=100)
+ crew_max_execution_time: int = Field(default=3600) # 1 hour
+ default_llm_model: str = Field(default="gpt-4")
+ fallback_llm_model: str = Field(default="gpt-3.5-turbo")
+
+ # Memory and Storage
+ crewai_storage_dir: str = Field(default="./storage", env="CREWAI_STORAGE_DIR")
+ memory_enabled: bool = Field(default=True)
+ memory_cleanup_interval: int = Field(default=86400) # 24 hours in seconds
+
+ # Performance
+ enable_caching: bool = Field(default=True)
+ max_retries: int = Field(default=3)
+ retry_delay: float = Field(default=1.0)
+
+ # Monitoring
+ enable_monitoring: bool = Field(default=True)
+ log_level: str = Field(default="INFO")
+ metrics_export_interval: int = Field(default=3600) # 1 hour
+
+ # Security
+ input_sanitization: bool = Field(default=True)
+ max_input_length: int = Field(default=10000)
+ allowed_file_types: list = Field(default=["txt", "md", "pdf", "docx"])
+
+ @validator('environment', pre=True)
+ def set_debug_based_on_env(cls, v):
+ return v
+
+ @validator('debug')
+ def set_debug_from_env(cls, v, values):
+ env = values.get('environment')
+ if env == Environment.PRODUCTION:
+ return False
+ return v
+
+ @validator('openai_api_key')
+ def validate_openai_key(cls, v):
+ if not v:
+ raise ValueError("OPENAI_API_KEY is required")
+ if not v.startswith('sk-'):
+ raise ValueError("Invalid OpenAI API key format")
+ return v
+
+ @property
+ def is_production(self) -> bool:
+ return self.environment == Environment.PRODUCTION
+
+ @property
+ def is_development(self) -> bool:
+ return self.environment == Environment.DEVELOPMENT
+
+ def get_llm_config(self) -> Dict[str, Any]:
+ """Get LLM configuration based on environment"""
+ config = {
+ "model": self.default_llm_model,
+ "temperature": 0.1 if self.is_production else 0.3,
+ "max_tokens": 4000 if self.is_production else 2000,
+ "timeout": 60
+ }
+
+ if self.is_development:
+ config["model"] = self.fallback_llm_model
+
+ return config
+
+ def get_memory_config(self) -> Dict[str, Any]:
+ """Get memory configuration"""
+ return {
+ "enabled": self.memory_enabled,
+ "storage_dir": self.crewai_storage_dir,
+ "cleanup_interval": self.memory_cleanup_interval,
+ "provider": "mem0" if self.mem0_api_key and self.is_production else "local"
+ }
+
+ class Config:
+ env_file = ".env"
+ env_file_encoding = 'utf-8'
+ case_sensitive = False
+
+# Global settings instance
+settings = CrewAISettings()
+
+# Usage in crew
+@CrewBase
+class ConfigurableCrew():
+ """Crew that uses centralized configuration"""
+
+ def __init__(self):
+ self.settings = settings
+ self.validate_configuration()
+
+ def validate_configuration(self):
+ """Validate configuration before crew execution"""
+ required_keys = [self.settings.openai_api_key]
+ if not all(required_keys):
+ raise ConfigurationError("Missing required API keys")
+
+ if not os.path.exists(self.settings.crewai_storage_dir):
+ os.makedirs(self.settings.crewai_storage_dir, exist_ok=True)
+
+ @agent
+ def adaptive_agent(self) -> Agent:
+ """Agent that adapts to configuration"""
+ llm_config = self.settings.get_llm_config()
+
+ return Agent(
+ config=self.agents_config['researcher'],
+ llm=llm_config["model"],
+ max_iter=15 if self.settings.is_production else 10,
+ max_execution_time=self.settings.crew_max_execution_time,
+ verbose=self.settings.debug
+ )
+```
+
+### Comprehensive Testing Framework:
+```python
+import pytest
+import asyncio
+from unittest.mock import Mock, patch, MagicMock
+from crewai import Agent, Task, Crew
+from crewai.tasks.task_output import TaskOutput
+
+class CrewAITestFramework:
+ """Comprehensive testing framework for CrewAI applications"""
+
+ @staticmethod
+ def create_mock_agent(role: str = "test_agent", tools: list = None) -> Mock:
+ """Create a mock agent for testing"""
+ mock_agent = Mock(spec=Agent)
+ mock_agent.role = role
+ mock_agent.goal = f"Test goal for {role}"
+ mock_agent.backstory = f"Test backstory for {role}"
+ mock_agent.tools = tools or []
+ mock_agent.llm = "gpt-3.5-turbo"
+ mock_agent.verbose = False
+ return mock_agent
+
+ @staticmethod
+ def create_mock_task_output(content: str, success: bool = True,
+ tokens: int = 100) -> TaskOutput:
+ """Create a mock task output for testing"""
+ return TaskOutput(
+ description="Test task",
+ raw=content,
+ agent="test_agent",
+ pydantic=None,
+ json_dict=None
+ )
+
+ @staticmethod
+ def create_test_crew(agents: list = None, tasks: list = None) -> Crew:
+ """Create a test crew with mock components"""
+ test_agents = agents or [CrewAITestFramework.create_mock_agent()]
+ test_tasks = tasks or []
+
+ return Crew(
+ agents=test_agents,
+ tasks=test_tasks,
+ verbose=False
+ )
+
+# Example test cases
+class TestResearchCrew:
+ """Test cases for research crew functionality"""
+
+ def setup_method(self):
+ """Setup test environment"""
+ self.framework = CrewAITestFramework()
+ self.mock_serper = Mock()
+
+ @patch('crewai_tools.SerperDevTool')
+ def test_agent_creation(self, mock_serper_tool):
+ """Test agent creation with proper configuration"""
+ mock_serper_tool.return_value = self.mock_serper
+
+ crew = ResearchCrew()
+ researcher = crew.researcher()
+
+ assert researcher.role == "Senior Research Analyst"
+ assert len(researcher.tools) > 0
+ assert researcher.verbose is True
+
+ def test_task_validation(self):
+ """Test task validation logic"""
+ crew = ResearchCrew()
+
+ # Test valid output
+ valid_output = self.framework.create_mock_task_output(
+ "This is a comprehensive research summary with conclusions and findings."
+ )
+ is_valid, message = crew.validate_research_quality(valid_output)
+ assert is_valid is True
+
+ # Test invalid output (too short)
+ invalid_output = self.framework.create_mock_task_output("Too short")
+ is_valid, message = crew.validate_research_quality(invalid_output)
+ assert is_valid is False
+ assert "brief" in message.lower()
+
+ @patch('requests.get')
+ def test_tool_error_handling(self, mock_requests):
+ """Test tool error handling and recovery"""
+ # Simulate network error
+ mock_requests.side_effect = requests.exceptions.RequestException("Network error")
+
+ tool = RobustSearchTool()
+ result = tool._run("test query")
+
+ assert "network error" in result.lower()
+ assert "failed" in result.lower()
+
+ @pytest.mark.asyncio
+ async def test_crew_execution_flow(self):
+ """Test complete crew execution with mocked dependencies"""
+ with patch.object(Agent, 'execute_task') as mock_execute:
+ mock_execute.return_value = self.framework.create_mock_task_output(
+ "Research completed successfully with findings and recommendations."
+ )
+
+ crew = ResearchCrew()
+ result = crew.crew().kickoff(inputs={"topic": "AI testing"})
+
+ assert result is not None
+ assert "successfully" in result.raw.lower()
+
+ def test_memory_integration(self):
+ """Test memory system integration"""
+ crew = ResearchCrew()
+ memory_manager = AdvancedMemoryManager(crew)
+
+ # Test saving to memory
+ test_content = "Important research finding about AI"
+ memory_manager.save_with_context(
+ content=test_content,
+ memory_type="short_term",
+ metadata={"importance": "high"},
+ agent="researcher"
+ )
+
+ # Test searching memory
+ results = memory_manager.search_across_memories("AI research")
+ assert "short_term" in results
+
+ def test_error_handling_workflow(self):
+ """Test error handling and recovery mechanisms"""
+ error_handler = ErrorHandler("test_crew")
+
+ # Test error registration and handling
+ test_error = TaskExecutionError("Test task failed", ErrorSeverity.MEDIUM)
+ result = error_handler.handle_error(test_error)
+
+ assert len(error_handler.error_log) == 1
+ assert error_handler.error_log[0].severity == ErrorSeverity.MEDIUM
+
+ def test_configuration_validation(self):
+ """Test configuration validation"""
+ # Test with missing API key
+ with patch.dict(os.environ, {}, clear=True):
+ with pytest.raises(ValueError):
+ settings = CrewAISettings()
+
+ # Test with valid configuration
+ with patch.dict(os.environ, {"OPENAI_API_KEY": "sk-test-key"}):
+ settings = CrewAISettings()
+ assert settings.openai_api_key == "sk-test-key"
+
+ @pytest.mark.integration
+ def test_end_to_end_workflow(self):
+ """Integration test for complete workflow"""
+ # This would test the entire crew workflow with real components
+ # Use sparingly and with proper API key management
+ pass
+
+# Performance testing
+class TestCrewPerformance:
+ """Performance tests for CrewAI applications"""
+
+ def test_memory_usage(self):
+ """Test memory usage during crew execution"""
+ import psutil
+ import gc
+
+ process = psutil.Process()
+ initial_memory = process.memory_info().rss
+
+ # Create and run crew multiple times
+ for i in range(10):
+ crew = ResearchCrew()
+ # Simulate crew execution
+ del crew
+ gc.collect()
+
+ final_memory = process.memory_info().rss
+ memory_increase = final_memory - initial_memory
+
+ # Assert memory increase is reasonable (less than 100MB)
+ assert memory_increase < 100 * 1024 * 1024
+
+ def test_concurrent_execution(self):
+ """Test concurrent crew execution"""
+ import concurrent.futures
+
+ def run_crew(crew_id):
+ crew = ResearchCrew()
+ # Simulate execution
+ return f"crew_{crew_id}_completed"
+
+ with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+ futures = [executor.submit(run_crew, i) for i in range(5)]
+ results = [future.result() for future in futures]
+
+ assert len(results) == 5
+ assert all("completed" in result for result in results)
+
+# Run tests with coverage
+# pytest --cov=src --cov-report=html --cov-report=term tests/
+```
+
+## Troubleshooting Common Issues
+
+### Memory and Performance Issues:
+- **Large memory usage**: Implement memory cleanup, use score thresholds, monitor ChromaDB size
+- **Slow LLM responses**: Optimize prompts, use appropriate model sizes, implement caching
+- **High token costs**: Implement output caching, use context efficiently, set token limits
+- **Memory leaks**: Properly dispose of crew instances, monitor memory usage, use garbage collection
+
+### Configuration and Setup Issues:
+- **YAML parsing errors**: Validate YAML syntax, check indentation, use YAML linters
+- **Missing environment variables**: Use .env.example, validate at startup, provide clear error messages
+- **Tool import failures**: Ensure proper tool installation, check import paths, verify dependencies
+- **API key issues**: Validate key format, check permissions, implement key rotation
+
+### Storage and Persistence Issues:
+- **Permission errors**: Check CREWAI_STORAGE_DIR permissions, ensure write access
+- **Database locks**: Ensure single crew instance access, implement proper connection handling
+- **Storage growth**: Implement cleanup strategies, monitor disk usage, archive old data
+- **ChromaDB issues**: Check vector database health, validate embeddings, handle corrupted indices
+
+## Local Development and Testing
+
+### Development Best Practices:
+- Validate all API keys and credentials in .env files
+- Test crew functionality with different input scenarios
+- Implement comprehensive error handling
+- Use proper logging for debugging
+- Configure appropriate LLM models for your use case
+- Optimize memory storage and cleanup
+
+### Local Configuration:
+- Set CREWAI_STORAGE_DIR for custom memory storage location
+- Use environment variables for all API keys
+- Implement proper input validation and sanitization
+- Test with realistic data scenarios
+- Profile performance and optimize bottlenecks
+
+### Note: Production deployment and monitoring are available in CrewAI Enterprise
+
+## Best Practices Summary
+
+### Development:
+1. Always use .env files for sensitive configuration
+2. Implement comprehensive error handling and logging
+3. Use structured outputs with Pydantic for reliability
+4. Test crew functionality with different input scenarios
+5. Follow CrewAI patterns and conventions consistently
+6. Use UV for dependency management as per CrewAI standards
+7. Implement proper validation for all inputs and outputs
+8. Optimize performance for your specific use cases
+
+### Security:
+1. Never commit API keys or sensitive data to version control
+2. Implement input validation and sanitization
+3. Use proper authentication and authorization
+4. Follow principle of least privilege for tool access
+5. Implement rate limiting and abuse prevention
+6. Monitor for security threats and anomalies
+7. Keep dependencies updated and secure
+8. Implement audit logging for sensitive operations
+
+### Performance:
+1. Optimize LLM calls and implement caching where appropriate
+2. Use appropriate model sizes for different tasks
+3. Implement efficient memory management and cleanup
+4. Monitor token usage and implement cost controls
+5. Use async patterns for I/O-bound operations
+6. Implement proper connection pooling and resource management
+7. Profile and optimize critical paths
+8. Plan for horizontal scaling when needed
\ No newline at end of file
diff --git a/docs/docs.json b/docs/docs.json
index 2823d97cb..0a195f309 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -41,6 +41,11 @@
"anchor": "Get Help",
"href": "mailto:[email protected]",
"icon": "headset"
+ },
+ {
+ "anchor": "Releases",
+ "href": "https://github.com/crewAIInc/crewAI/releases",
+ "icon": "tag"
}
]
},
@@ -89,6 +94,7 @@
"pages": [
"en/guides/advanced/customizing-prompts",
"en/guides/advanced/fingerprinting"
+
]
}
]
@@ -358,7 +364,7 @@
},
{
"tab": "Examples",
- "groups": [
+ "groups": [
{
"group": "Examples",
"pages": [
@@ -366,18 +372,8 @@
]
}
]
- },
- {
- "tab": "Releases",
- "groups": [
- {
- "group": "Releases",
- "pages": [
- "en/changelog"
- ]
- }
- ]
}
+
]
},
{
@@ -403,6 +399,11 @@
"anchor": "Obter Ajuda",
"href": "mailto:[email protected]",
"icon": "headset"
+ },
+ {
+ "anchor": "Lançamentos",
+ "href": "https://github.com/crewAIInc/crewAI/releases",
+ "icon": "tag"
}
]
},
@@ -720,7 +721,7 @@
},
{
"tab": "Exemplos",
- "groups": [
+ "groups": [
{
"group": "Exemplos",
"pages": [
@@ -728,18 +729,8 @@
]
}
]
- },
- {
- "tab": "Lançamentos",
- "groups": [
- {
- "group": "Lançamentos",
- "pages": [
- "pt-BR/changelog"
- ]
- }
- ]
}
+
]
}
]
@@ -777,6 +768,64 @@
"seo": {
"indexing": "all"
},
+ "redirects": [
+ {
+ "source": "/introduction",
+ "destination": "/en/introduction"
+ },
+ {
+ "source": "/installation",
+ "destination": "/en/installation"
+ },
+ {
+ "source": "/quickstart",
+ "destination": "/en/quickstart"
+ },
+ {
+ "source": "/changelog",
+ "destination": "https://github.com/crewAIInc/crewAI/releases"
+ },
+ {
+ "source": "/telemetry",
+ "destination": "/en/telemetry"
+ },
+ {
+ "source": "/concepts/:path*",
+ "destination": "/en/concepts/:path*"
+ },
+ {
+ "source": "/guides/:path*",
+ "destination": "/en/guides/:path*"
+ },
+ {
+ "source": "/tools/:path*",
+ "destination": "/en/tools/:path*"
+ },
+ {
+ "source": "/learn/:path*",
+ "destination": "/en/learn/:path*"
+ },
+ {
+ "source": "/mcp/:path*",
+ "destination": "/en/mcp/:path*"
+ },
+ {
+ "source": "/observability/:path*",
+ "destination": "/en/observability/:path*"
+ },
+ {
+ "source": "/enterprise/:path*",
+ "destination": "/en/enterprise/:path*"
+ },
+ {
+ "source": "/api-reference/:path*",
+ "destination": "/en/api-reference/:path*"
+ },
+ {
+ "source": "/examples/:path*",
+ "destination": "/en/examples/:path*"
+ }
+ ],
"errors": {
"404": {
"redirect": true
diff --git a/docs/en/changelog.mdx b/docs/en/changelog.mdx
deleted file mode 100644
index 6dfc5d1f9..000000000
--- a/docs/en/changelog.mdx
+++ /dev/null
@@ -1,473 +0,0 @@
----
-title: Changelog
-description: View the latest updates and changes to CrewAI
-icon: timeline
----
-
-<Update label="2024-05-22" description="v0.121.0" tags={["Latest"]}>
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01210.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.121.0">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Fixed encoding error when creating tools
- - Fixed failing llama test
- - Updated logging configuration for consistency
- - Enhanced telemetry initialization and event handling
-
- **New Features & Enhancements**
- - Added **markdown attribute** to the Task class
- - Added **reasoning attribute** to the Agent class
- - Added **inject_date flag** to Agent for automatic date injection
- - Implemented **HallucinationGuardrail** (no-op with test coverage)
-
- **Documentation & Guides**
- - Added documentation for **StagehandTool** and improved MDX structure
- - Added documentation for **MCP integration** and updated enterprise docs
- - Documented knowledge events and updated reasoning docs
- - Added stop parameter documentation
- - Fixed import references in doc examples (before_kickoff, after_kickoff)
- - General docs updates and restructuring for clarity
-</Update>
-
-<Update label="2024-05-15" description="v0.120.1">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01201.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.120.1">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Fixed **interpolation with hyphens**
-</Update>
-
-<Update label="2024-05-14" description="v0.120.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01200.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.120.0">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Enabled **full Ruff rule set** by default for stricter linting
- - Addressed race condition in FilteredStream using context managers
- - Fixed agent knowledge reset issue
- - Refactored agent fetching logic into utility module
-
- **New Features & Enhancements**
- - Added support for **loading an Agent directly from a repository**
- - Enabled setting an empty context for Task
- - Enhanced Agent repository feedback and fixed Tool auto-import behavior
- - Introduced direct initialization of knowledge (bypassing knowledge_sources)
-
- **Documentation & Guides**
- - Updated security.md for current security practices
- - Cleaned up Google setup section for clarity
- - Added link to AI Studio when entering Gemini key
- - Updated Arize Phoenix observability guide
- - Refreshed flow documentation
-</Update>
-
-<Update label="2024-05-08" description="v0.119.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01190.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.119.0">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Improved test reliability by enhancing pytest handling for flaky tests
- - Fixed memory reset crash when embedding dimensions mismatch
- - Enabled parent flow identification for Crew and LiteAgent
- - Prevented telemetry-related crashes when unavailable
- - Upgraded **LiteLLM version** for better compatibility
- - Fixed llama converter tests by removing skip_external_api
-
- **New Features & Enhancements**
- - Introduced **knowledge retrieval prompt re-writing** in Agent for improved tracking and debugging
- - Made LLM setup and quickstart guides model-agnostic
-
- **Documentation & Guides**
- - Added advanced configuration docs for the RAG tool
- - Updated Windows troubleshooting guide
- - Refined documentation examples for better clarity
- - Fixed typos across docs and config files
-</Update>
-
-<Update label="2024-04-28" description="v0.118.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01180.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.118.0">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Fixed issues with missing prompt or system templates
- - Removed global logging configuration to avoid unintended overrides
- - Renamed **TaskGuardrail to LLMGuardrail** for improved clarity
- - Downgraded litellm to version 1.167.1 for compatibility
- - Added missing init.py files to ensure proper module initialization
-
- **New Features & Enhancements**
- - Added support for **no-code Guardrail creation** to simplify AI behavior controls
-
- **Documentation & Guides**
- - Removed CrewStructuredTool from public documentation to reflect internal usage
- - Updated enterprise documentation and YouTube embed for improved onboarding experience
-</Update>
-
-<Update label="2024-04-20" description="v0.117.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01170.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.117.0">View on GitHub</a>
- </div>
-
- **New Features & Enhancements**
- - Added `result_as_answer` parameter support in `@tool` decorator.
- - Introduced support for new language models: GPT-4.1, Gemini-2.0, and Gemini-2.5 Pro.
- - Enhanced knowledge management capabilities.
- - Added Huggingface provider option in CLI.
- - Improved compatibility and CI support for Python 3.10+.
-
- **Core Improvements & Fixes**
- - Fixed issues with incorrect template parameters and missing inputs.
- - Improved asynchronous flow handling with coroutine condition checks.
- - Enhanced memory management with isolated configuration and correct memory object copying.
- - Fixed initialization of lite agents with correct references.
- - Addressed Python type hint issues and removed redundant imports.
- - Updated event placement for improved tool usage tracking.
- - Raised explicit exceptions when flows fail.
- - Removed unused code and redundant comments from various modules.
- - Updated GitHub App token action to v2.
-
- **Documentation & Guides**
- - Enhanced documentation structure, including enterprise deployment instructions.
- - Automatically create output folders for documentation generation.
- - Fixed broken link in WeaviateVectorSearchTool documentation.
- - Fixed guardrail documentation usage and import paths for JSON search tools.
- - Updated documentation for CodeInterpreterTool.
- - Improved SEO, contextual navigation, and error handling for documentation pages.
-</Update>
-
-<Update label="2024-04-25" description="v0.117.1">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01171.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.117.1">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Upgraded **crewai-tools** to latest version
- - Upgraded **liteLLM** to latest version
- - Fixed **Mem0 OSS**
-</Update>
-
-<Update label="2024-04-07" description="v0.114.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01140.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.114.0">View on GitHub</a>
- </div>
-
- **New Features & Enhancements**
- - Agents as an atomic unit. (`Agent(...).kickoff()`)
- - Support for [Custom LLM implementations](https://docs.crewai.com/guides/advanced/custom-llm).
- - Integrated External Memory and [Opik observability](https://docs.crewai.com/how-to/opik-observability).
- - Enhanced YAML extraction.
- - Multimodal agent validation.
- - Added Secure fingerprints for agents and crews.
-
- **Core Improvements & Fixes**
- - Improved serialization, agent copying, and Python compatibility.
- - Added wildcard support to `emit()`
- - Added support for additional router calls and context window adjustments.
- - Fixed typing issues, validation, and import statements.
- - Improved method performance.
- - Enhanced agent task handling, event emissions, and memory management.
- - Fixed CLI issues, conditional tasks, cloning behavior, and tool outputs.
-
- **Documentation & Guides**
- - Improved documentation structure, theme, and organization.
- - Added guides for Local NVIDIA NIM with WSL2, W&B Weave, and Arize Phoenix.
- - Updated tool configuration examples, prompts, and observability docs.
- - Guide on using singular agents within Flows.
-</Update>
-
-<Update label="2024-03-17" description="v0.108.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01080.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.108.0">View on GitHub</a>
- </div>
-
- **New Features & Enhancements**
- - Converted tabs to spaces in `crew.py` template
- - Enhanced LLM Streaming Response Handling and Event System
- - Included `model_name`
- - Enhanced Event Listener with rich visualization and improved logging
- - Added fingerprints
-
- **Bug Fixes**
- - Fixed Mistral issues
- - Fixed a bug in documentation
- - Fixed type check error in fingerprint property
-
- **Documentation Updates**
- - Improved tool documentation
- - Updated installation guide for the `uv` tool package
- - Added instructions for upgrading crewAI with the `uv` tool
- - Added documentation for `ApifyActorsTool`
-</Update>
-
-<Update label="2024-03-10" description="v0.105.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01050.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.105.0">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Fixed issues with missing template variables and user memory configuration
- - Improved async flow support and addressed agent response formatting
- - Enhanced memory reset functionality and fixed CLI memory commands
- - Fixed type issues, tool calling properties, and telemetry decoupling
-
- **New Features & Enhancements**
- - Added Flow state export and improved state utilities
- - Enhanced agent knowledge setup with optional crew embedder
- - Introduced event emitter for better observability and LLM call tracking
- - Added support for Python 3.10 and ChatOllama from langchain_ollama
- - Integrated context window size support for the o3-mini model
- - Added support for multiple router calls
-
- **Documentation & Guides**
- - Improved documentation layout and hierarchical structure
- - Added QdrantVectorSearchTool guide and clarified event listener usage
- - Fixed typos in prompts and updated Amazon Bedrock model listings
-</Update>
-
-<Update label="2024-02-12" description="v0.102.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01020.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.102.0">View on GitHub</a>
- </div>
-
- **Core Improvements & Fixes**
- - Enhanced LLM Support: Improved structured LLM output, parameter handling, and formatting for Anthropic models
- - Crew & Agent Stability: Fixed issues with cloning agents/crews using knowledge sources, multiple task outputs in conditional tasks, and ignored Crew task callbacks
- - Memory & Storage Fixes: Fixed short-term memory handling with Bedrock, ensured correct embedder initialization, and added a reset memories function in the crew class
- - Training & Execution Reliability: Fixed broken training and interpolation issues with dict and list input types
-
- **New Features & Enhancements**
- - Advanced Knowledge Management: Improved naming conventions and enhanced embedding configuration with custom embedder support
- - Expanded Logging & Observability: Added JSON format support for logging and integrated MLflow tracing documentation
- - Data Handling Improvements: Updated excel_knowledge_source.py to process multi-tab files
- - General Performance & Codebase Clean-Up: Streamlined enterprise code alignment and resolved linting issues
- - Adding new tool: `QdrantVectorSearchTool`
-
- **Documentation & Guides**
- - Updated AI & Memory Docs: Improved Bedrock, Google AI, and long-term memory documentation
- - Task & Workflow Clarity: Added "Human Input" row to Task Attributes, Langfuse guide, and FileWriterTool documentation
- - Fixed Various Typos & Formatting Issues
-</Update>
-
-<Update label="2024-01-28" description="v0.100.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v01000.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.100.0">View on GitHub</a>
- </div>
-
- **Features**
- - Add Composio docs
- - Add SageMaker as a LLM provider
-
- **Fixes**
- - Overall LLM connection issues
- - Using safe accessors on training
- - Add version check to crew_chat.py
-
- **Documentation**
- - New docs for crewai chat
- - Improve formatting and clarity in CLI and Composio Tool docs
-</Update>
-
-<Update label="2024-01-20" description="v0.98.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v0980.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.98.0">View on GitHub</a>
- </div>
-
- **Features**
- - Conversation crew v1
- - Add unique ID to flow states
- - Add @persist decorator with FlowPersistence interface
-
- **Integrations**
- - Add SambaNova integration
- - Add NVIDIA NIM provider in cli
- - Introducing VoyageAI
-
- **Fixes**
- - Fix API Key Behavior and Entity Handling in Mem0 Integration
- - Fixed core invoke loop logic and relevant tests
- - Make tool inputs actual objects and not strings
- - Add important missing parts to creating tools
- - Drop litellm version to prevent windows issue
- - Before kickoff if inputs are none
- - Fixed typos, nested pydantic model issue, and docling issues
-</Update>
-
-<Update label="2024-01-04" description="v0.95.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v0950.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.95.0">View on GitHub</a>
- </div>
-
- **New Features**
- - Adding Multimodal Abilities to Crew
- - Programatic Guardrails
- - HITL multiple rounds
- - Gemini 2.0 Support
- - CrewAI Flows Improvements
- - Add Workflow Permissions
- - Add support for langfuse with litellm
- - Portkey Integration with CrewAI
- - Add interpolate_only method and improve error handling
- - Docling Support
- - Weviate Support
-
- **Fixes**
- - output_file not respecting system path
- - disk I/O error when resetting short-term memory
- - CrewJSONEncoder now accepts enums
- - Python max version
- - Interpolation for output_file in Task
- - Handle coworker role name case/whitespace properly
- - Add tiktoken as explicit dependency and document Rust requirement
- - Include agent knowledge in planning process
- - Change storage initialization to None for KnowledgeStorage
- - Fix optional storage checks
- - include event emitter in flows
- - Docstring, Error Handling, and Type Hints Improvements
- - Suppressed userWarnings from litellm pydantic issues
-</Update>
-
-<Update label="2024-12-05" description="v0.86.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v0860.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.86.0">View on GitHub</a>
- </div>
- **Changes**
- - Remove all references to pipeline and pipeline router
- - Add Nvidia NIM as provider in Custom LLM
- - Add knowledge demo + improve knowledge docs
- - Add HITL multiple rounds of followup
- - New docs about yaml crew with decorators
- - Simplify template crew
-</Update>
-
-<Update label="2024-12-04" description="v0.85.0">
- ## Release Highlights
- <Frame>
- <img src="/images/releases/v0850.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.85.0">View on GitHub</a>
- </div>
- **Features**
- - Added knowledge to agent level
- - Feat/remove langchain
- - Improve typed task outputs
- - Log in to Tool Repository on crewai login
-
- **Fixes**
- - Fixes issues with result as answer not properly exiting LLM loop
- - Fix missing key name when running with ollama provider
- - Fix spelling issue found
-
- **Documentation**
- - Update readme for running mypy
- - Add knowledge to mint.json
- - Update Github actions
- - Update Agents docs to include two approaches for creating an agent
- - Improvements to LLM Configuration and Usage
-</Update>
-
-<Update label="2024-11-25" description="v0.83.0">
- **New Features**
- - New before_kickoff and after_kickoff crew callbacks
- - Support to pre-seed agents with Knowledge
- - Add support for retrieving user preferences and memories using Mem0
-
- **Fixes**
- - Fix Async Execution
- - Upgrade chroma and adjust embedder function generator
- - Update CLI Watson supported models + docs
- - Reduce level for Bandit
- - Fixing all tests
-
- **Documentation**
- - Update Docs
-</Update>
-
-<Update label="2024-11-13" description="v0.80.0">
- **Fixes**
- - Fixing Tokens callback replacement bug
- - Fixing Step callback issue
- - Add cached prompt tokens info on usage metrics
- - Fix crew_train_success test
-</Update>
\ No newline at end of file
diff --git a/docs/en/installation.mdx b/docs/en/installation.mdx
index f8f0af242..f319d0a40 100644
--- a/docs/en/installation.mdx
+++ b/docs/en/installation.mdx
@@ -72,7 +72,7 @@ If you haven't installed `uv` yet, follow **step 1** to quickly get it set up on
</Warning>
<Warning>
- If you encounter the `chroma-hnswlib==0.7.6` build error (`fatal error C1083: Cannot open include file: 'float.h'`) on Windows, install (Visual Studio Build Tools)[https://visualstudio.microsoft.com/downloads/] with *Desktop development with C++*.
+ If you encounter the `chroma-hnswlib==0.7.6` build error (`fatal error C1083: Cannot open include file: 'float.h'`) on Windows, install [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/) with *Desktop development with C++*.
</Warning>
- To verify that `crewai` is installed, run:
@@ -104,7 +104,6 @@ We recommend using the `YAML` template scaffolding for a structured approach to
```
- This creates a new project with the following structure:
- <Frame>
```
my_project/
├── .gitignore
@@ -124,7 +123,6 @@ We recommend using the `YAML` template scaffolding for a structured approach to
├── agents.yaml
└── tasks.yaml
```
- </Frame>
</Step>
<Step title="Customize Your Project">
diff --git a/docs/pt-BR/changelog.mdx b/docs/pt-BR/changelog.mdx
deleted file mode 100644
index 722d696a7..000000000
--- a/docs/pt-BR/changelog.mdx
+++ /dev/null
@@ -1,473 +0,0 @@
----
-title: Registro de Alterações
-description: Veja as atualizações e mudanças mais recentes do CrewAI
-icon: timeline
----
-
-<Update label="2024-05-22" description="v0.121.0" tags={["Latest"]}>
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01210.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.121.0">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Corrigido erro de codificação ao criar ferramentas
- - Corrigido teste do llama com falha
- - Configuração de logs atualizada para mais consistência
- - Inicialização e tratamento de eventos de telemetria aprimorados
-
- **Novas Funcionalidades & Aprimoramentos**
- - Adicionado **atributo markdown** à classe Task
- - Adicionado **atributo reasoning** à classe Agent
- - Adicionada flag **inject_date** ao Agent para injeção automática de data
- - Implementado **HallucinationGuardrail** (sem-operação, com cobertura de testes)
-
- **Documentação & Guias**
- - Documentação adicionada para **StagehandTool** e melhoria na estrutura MDX
- - Inclusa documentação para integração **MCP** e atualização nos docs corporativos
- - Eventos de conhecimento documentados e documentação de reasoning atualizada
- - Adicionada explicação do parâmetro stop
- - Corrigidas referências de import nos exemplos de documentação (before_kickoff, after_kickoff)
- - Atualizações gerais e reestruturação nos docs para maior clareza
-</Update>
-
-<Update label="2024-05-15" description="v0.120.1">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01201.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.120.1">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Corrigida **interpolação com hífens**
-</Update>
-
-<Update label="2024-05-14" description="v0.120.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01200.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.120.0">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Conjunto completo de regras do Ruff habilitado por padrão para linting mais rigoroso
- - Corrigida condição de corrida no FilteredStream usando context managers
- - Corrigido problema de reset de conhecimento do agente
- - Lógica de busca de agente refatorada para módulo utilitário
-
- **Novas Funcionalidades & Aprimoramentos**
- - Suporte adicionado para **carregar um Agent diretamente de um repositório**
- - Permitida configuração de contexto vazio em Task
- - Feedback do repositório de Agent aprimorado e correção no comportamento de auto-import de Tool
- - Inicialização direta de conhecimento introduzida (bypassando knowledge_sources)
-
- **Documentação & Guias**
- - security.md atualizado para refletir práticas atuais de segurança
- - Seção de configuração do Google revisada para mais clareza
- - Adicionado link para AI Studio ao inserir chave Gemini
- - Guia de observabilidade do Arize Phoenix atualizado
- - Documentação de fluxo renovada
-</Update>
-
-<Update label="2024-05-08" description="v0.119.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01190.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.119.0">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Confiabilidade de testes aprimorada melhorando o tratamento do pytest para testes instáveis
- - Corrigido crash no reset de memória por incompatibilidade de dimensões de embeddings
- - Identificação do fluxo pai habilitada para Crew e LiteAgent
- - Crashes de telemetria prevenidos quando indisponíveis
- - Atualização da versão do **LiteLLM** para melhor compatibilidade
- - Corrigidos testes do conversor de llama removendo skip_external_api
-
- **Novas Funcionalidades & Aprimoramentos**
- - Introduzida **reescrita de prompt de recuperação de conhecimento** no Agent para melhor rastreamento e debug
- - Guias de configuração do LLM e início rápido tornados independentes do modelo
-
- **Documentação & Guias**
- - Adicionada documentação de configuração avançada para o RAG tool
- - Guia de resolução de problemas no Windows atualizado
- - Exemplos na documentação refinados para maior clareza
- - Correção de erros ortográficos em docs e arquivos de configuração
-</Update>
-
-<Update label="2024-04-28" description="v0.118.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01180.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.118.0">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Corrigidos problemas com prompt ou templates de sistema ausentes
- - Removida configuração global de logs para evitar sobreposição não intencional
- - Renomeado **TaskGuardrail para LLMGuardrail** para maior clareza
- - Versão do litellm rebaixada para 1.167.1 visando compatibilidade
- - Adicionados arquivos init.py ausentes para garantir inicialização correta dos módulos
-
- **Novas Funcionalidades & Aprimoramentos**
- - Suporte adicionado para **criação de Guardrails sem código** facilitando o controle de comportamento da IA
-
- **Documentação & Guias**
- - CrewStructuredTool removido da documentação pública para refletir uso interno
- - Documentação corporativa e embed do YouTube atualizados para melhor onboarding
-</Update>
-
-<Update label="2024-04-20" description="v0.117.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01170.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.117.0">Ver no GitHub</a>
- </div>
-
- **Novas Funcionalidades & Aprimoramentos**
- - Adicionado suporte ao parâmetro `result_as_answer` no decorator `@tool`.
- - Suporte a novos modelos de linguagem: GPT-4.1, Gemini-2.0 e Gemini-2.5 Pro.
- - Capacidades de gerenciamento de conhecimento aprimoradas.
- - Adicionado provedor Huggingface na CLI.
- - Compatibilidade e suporte CI melhorados para Python 3.10+.
-
- **Melhorias & Correções no Núcleo**
- - Corrigidos problemas com parâmetros de template incorretos e entradas ausentes.
- - Fluxo assíncrono aprimorado com verificações de condição coroutine.
- - Gerenciamento de memória aprimorado com configuração isolada e cópia correta dos objetos.
- - Inicialização de lite agents corrigida com referências corretas.
- - Corrigidos problemas de type hint em Python e remoção de imports redundantes.
- - Atualização do posicionamento de eventos para rastreamento do uso de ferramentas.
- - Exceções explícitas lançadas quando fluxos falham.
- - Remoção de código e comentários redundantes em diversos módulos.
- - Atualização da ação de token do GitHub App para v2.
-
- **Documentação & Guias**
- - Estrutura documental aprimorada, incluindo instruções para implantação corporativa.
- - Criação automática de pastas de saída para geração de documentação.
- - Link quebrado reparado na documentação do WeaviateVectorSearchTool.
- - Correções na documentação do guardrail e nos caminhos de import dos search tools para JSON.
- - Atualização na documentação do CodeInterpreterTool.
- - Aprimoramento de SEO, navegação contextual e tratamento de erros nas páginas de documentação.
-</Update>
-
-<Update label="2024-04-25" description="v0.117.1">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01171.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.117.1">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Versão do **crewai-tools** atualizada para a mais recente
- - Versão do **liteLLM** atualizada para a mais recente
- - Correção no **Mem0 OSS**
-</Update>
-
-<Update label="2024-04-07" description="v0.114.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01140.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.114.0">Ver no GitHub</a>
- </div>
-
- **Novas Funcionalidades & Aprimoramentos**
- - Agents como unidade atômica. (`Agent(...).kickoff()`)
- - Suporte para [implementações Custom LLM](https://docs.crewai.com/guides/advanced/custom-llm).
- - Memória externa integrada e [Opik observability](https://docs.crewai.com/how-to/opik-observability).
- - Extração de YAML aprimorada.
- - Validação multimodal de agentes.
- - Impressões digitais seguras adicionadas para agents e crews.
-
- **Melhorias & Correções no Núcleo**
- - Serialização, cópia de agent e compatibilidade Python aprimoradas.
- - Suporte a curingas adicionado a `emit()`
- - Suporte a chamadas adicionais do roteador e ajustes de janela de contexto.
- - Correções em typing, validação e imports.
- - Melhoria na performance de métodos.
- - Manipulação de tasks do agent, emissão de eventos e gerenciamento de memória aprimorados.
- - Correções na CLI, tarefas condicionais, comportamento de clonagem e saídas de ferramentas.
-
- **Documentação & Guias**
- - Estrutura, tema e organização da documentação aprimorados.
- - Guias para Local NVIDIA NIM com WSL2, W&B Weave e Arize Phoenix adicionados.
- - Exemplos de configuração de ferramentas, prompts e docs de observabilidade atualizados.
- - Guia para usar agentes singulares nos Flows.
-</Update>
-
-<Update label="2024-03-17" description="v0.108.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01080.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.108.0">Ver no GitHub</a>
- </div>
-
- **Novas Funcionalidades & Aprimoramentos**
- - Conversão de tabs para espaços no template `crew.py`
- - Streaming de respostas LLM e sistema de eventos aprimorados
- - Inclusão de `model_name`
- - Event Listener aprimorado com visualização rica e logs melhorados
- - Impressões digitais adicionadas
-
- **Correções de Bugs**
- - Correções de problemas com Mistral
- - Correção de bug na documentação
- - Correção de erro de type check na propriedade fingerprint
-
- **Atualizações em Documentação**
- - Documentação de ferramentas aprimorada
- - Guia de instalação atualizado para o pacote `uv` tool
- - Instruções adicionadas para upgrade do crewAI com o `uv` tool
- - Documentação para `ApifyActorsTool` incluída
-</Update>
-
-<Update label="2024-03-10" description="v0.105.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01050.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.105.0">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Correção de variáveis de template ausentes e configuração de memória de usuário
- - Suporte a fluxo assíncrono melhorado e resolução para formatação de respostas do agente
- - Função de reset de memória aprimorada e correção nos comandos de memória da CLI
- - Correções em tipos, propriedades de chamadas de ferramenta e desacoplamento de telemetria
-
- **Novas Funcionalidades & Aprimoramentos**
- - Exportação de estado do Flow e utilitários de estado melhorados
- - Configuração de conhecimento do agente aprimorada com embedder opcional para crew
- - Emissor de eventos adicionado para melhor observabilidade e rastreamento de chamadas LLM
- - Suporte para Python 3.10 e ChatOllama via langchain_ollama
- - Suporte ao tamanho da janela de contexto para o modelo o3-mini
- - Adicionada capacidade de múltiplas chamadas de roteador
-
- **Documentação & Guias**
- - Layout e estrutura hierárquica da documentação aprimorados
- - Guia para QdrantVectorSearchTool incluído e uso de event listener esclarecido
- - Correções de erros nos prompts e atualização da lista de modelos do Amazon Bedrock
-</Update>
-
-<Update label="2024-02-12" description="v0.102.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01020.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.102.0">Ver no GitHub</a>
- </div>
-
- **Melhorias & Correções no Núcleo**
- - Suporte LLM expandido: melhorar saída estruturada do LLM, manuseio de parâmetros e formatação para modelos Anthropic
- - Estabilidade de Crew & Agent: corrigido clonagem de agents/crews com knowledge sources, múltiplas saídas de task em tarefas condicionais e callbacks de tarefa de Crew ignorados
- - Correções de Memória & Armazenamento: melhora no gerenciamento de memória de curto prazo com Bedrock, inicialização correta do embedder e função reset memories adicionada na classe crew
- - Confiabilidade em Treinamento & Execução: corrigidos treinamento quebrado e questões de interpolação com tipos de entrada dict e list
-
- **Novas Funcionalidades & Aprimoramentos**
- - Gerenciamento Avançado de Conhecimento: convencionamento de nomes melhorado e configuração de embedding aprimorada com suporte a embedder customizado
- - Logging & Observabilidade Expandidos: suporte ao formato JSON para logging e documentação de rastreamento no MLflow integrada
- - Melhorias no Tratamento de Dados: atualização do excel_knowledge_source.py para processar arquivos com múltipl abas
- - Desempenho Geral & Limpeza do Código: alinhamento de código corporativo e resolução de problemas de linting
- - Novo tool adicionado: `QdrantVectorSearchTool`
-
- **Documentação & Guias**
- - Docs de AI & Memória atualizados: melhorias em documentação do Bedrock, Google AI e memória de longo prazo
- - Clareza em tarefas & fluxos: adicionada linha "Entrada Humana" em Task Attributes, guia para Langfuse e documentação para FileWriterTool
- - Diversas correções de ortografia & formatação
-</Update>
-
-<Update label="2024-01-28" description="v0.100.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v01000.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.100.0">Ver no GitHub</a>
- </div>
-
- **Funcionalidades**
- - Adição dos docs Composio
- - Adicionado SageMaker como provedor LLM
-
- **Correções**
- - Correção geral nas conexões LLM
- - Uso de acessores seguros no treinamento
- - Checagem de versão adicionada ao crew_chat.py
-
- **Documentação**
- - Novos docs para crewai chat
- - Melhorias no formato e clareza nos docs da CLI e da Composio Tool
-</Update>
-
-<Update label="2024-01-20" description="v0.98.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v0980.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.98.0">Ver no GitHub</a>
- </div>
-
- **Funcionalidades**
- - Conversation crew v1
- - Adição de ID único para estados de flow
- - Adição do decorator @persist com a interface FlowPersistence
-
- **Integrações**
- - Integração SambaNova adicionada
- - Novo provedor NVIDIA NIM na CLI
- - Apresentando VoyageAI
-
- **Correções**
- - Correção de comportamento de chave API e tratamento de entidades na integração com Mem0
- - Correção na lógica de invoke principal e nos testes relacionados
- - Inputs de ferramentas agora são objetos reais em vez de strings
- - Partes importantes adicionadas no processo de criação de ferramentas
- - Versão do litellm foi rebaixada para prevenir problema no Windows
- - Correção antes da execução caso inputs estejam nulos
- - Corrigidos erros, modelo pydantic aninhado e falhas de docling
-</Update>
-
-<Update label="2024-01-04" description="v0.95.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v0950.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.95.0">Ver no GitHub</a>
- </div>
-
- **Novas Funcionalidades**
- - Adição de habilidades multimodais ao Crew
- - Guardrails programáticos
- - HITL com múltiplas rodadas
- - Suporte ao Gemini 2.0
- - Melhorias em CrewAI Flows
- - Permissões de workflow adicionadas
- - Suporte a langfuse com litellm
- - Integração Portkey com CrewAI
- - Método interpolate_only e melhorias em tratamento de erros
- - Suporte ao Docling
- - Suporte ao Weviate
-
- **Correções**
- - output_file não respeitava caminho do sistema
- - Erro de I/O em disco ao resetar memória de curto prazo
- - CrewJSONEncoder agora aceita enums
- - Versão máxima do Python
- - Interpolação de output_file em Task
- - Manipulação adequada de nomes de funções coworker quanto a caixa e espaços
- - tiktoken adicionado como dependência explícita e documentação do requisito Rust
- - Inclusão do conhecimento do agent no processo de planejamento
- - Inicialização do armazenamento definida como None em KnowledgeStorage
- - Verificações opcionais de armazenamento corrigidas
- - Emissor de eventos incluído nos flows
- - Melhorias em docstring, tratamento de erros e type hints
- - Suppressão de userWarnings de problemas pydantic no litellm
-</Update>
-
-<Update label="2024-12-05" description="v0.86.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v0860.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.86.0">Ver no GitHub</a>
- </div>
- **Alterações**
- - Removidas todas referências a pipeline e roteador de pipeline
- - Adicionado Nvidia NIM como provedor em Custom LLM
- - Adicionado demo de knowledge + melhorias nos docs de knowledge
- - Adicionado suporte a múltiplas rodadas de HITL
- - Novos docs sobre crew em yaml com decorators
- - Template de crew simplificado
-</Update>
-
-<Update label="2024-12-04" description="v0.85.0">
- ## Destaques da Versão
- <Frame>
- <img src="/images/releases/v0850.png" />
- </Frame>
-
- <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
- <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.85.0">Ver no GitHub</a>
- </div>
- **Funcionalidades**
- - Adicionado conhecimento em nível de agent
- - Feat/remover langchain
- - Aprimoradas saídas tipadas das tasks
- - Login no Tool Repository ao fazer login no crewai
-
- **Correções**
- - Correção em issues de result as answer não encerrando loop do LLM corretamente
- - Correção de ausência de nome de chave ao rodar com o provedor ollama
- - Correção em erro ortográfico identificado
-
- **Documentação**
- - Atualização no readme para rodar mypy
- - Adição do conhecimento em mint.json
- - Atualização das ações do Github
- - Atualização na documentação de Agents para incluir duas abordagens na criação de agent
- - Melhorias na Configuração e Uso do LLM
-</Update>
-
-<Update label="2024-11-25" description="v0.83.0">
- **Novas Funcionalidades**
- - Novos callbacks before_kickoff e after_kickoff em crew
- - Suporte para pre-seed de agents com Knowledge
- - Adicionado suporte para recuperação de preferências de usuário e memórias usando Mem0
-
- **Correções**
- - Correção em execução assíncrona
- - Upgrade do chroma e ajuste no gerador de funções do embedder
- - Atualização do CLI Watson com modelos suportados + docs
- - Redução do nível para Bandit
- - Correção de todos os testes
-
- **Documentação**
- - Documentação atualizada
-</Update>
-
-<Update label="2024-11-13" description="v0.80.0">
- **Correções**
- - Correção em bug de substituição do callback Tokens
- - Correção em issue de callback Step
- - Informação de prompt tokens em cache adicionada nas métricas de uso
- - Correção no teste crew_train_success
-</Update>
\ No newline at end of file