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/.cursorrulesnew file mode 100644index 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 filediff --git a/docs/docs.json b/docs/docs.jsonindex 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": truediff --git a/docs/en/changelog.mdx b/docs/en/changelog.mdxdeleted file mode 100644index 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 filediff --git a/docs/en/installation.mdx b/docs/en/installation.mdxindex 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.mdxdeleted file mode 100644index 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