diff --git a/README.md b/README.md index 56652dd9d..c832d0025 100644 --- a/README.md +++ b/README.md @@ -62,9 +62,9 @@ With over 100,000 developers certified through our community courses at [learn.crewai.com](https://learn.crewai.com), CrewAI is rapidly becoming the standard for enterprise-ready AI automation. -# CrewAI AOP Suite +# CrewAI AMP Suite -CrewAI AOP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation. +CrewAI AMP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation. You can try one part of the suite the [Crew Control Plane for free](https://app.crewai.com) @@ -76,9 +76,9 @@ You can try one part of the suite the [Crew Control Plane for free](https://app. - **Advanced Security**: Built-in robust security and compliance measures ensuring safe deployment and management. - **Actionable Insights**: Real-time analytics and reporting to optimize performance and decision-making. - **24/7 Support**: Dedicated enterprise support to ensure uninterrupted operation and quick resolution of issues. -- **On-premise and Cloud Deployment Options**: Deploy CrewAI AOP on-premise or in the cloud, depending on your security and compliance requirements. +- **On-premise and Cloud Deployment Options**: Deploy CrewAI AMP on-premise or in the cloud, depending on your security and compliance requirements. -CrewAI AOP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient, +CrewAI AMP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient, intelligent automations. ## Table of contents @@ -124,7 +124,8 @@ Setup and run your first CrewAI agents by following this tutorial. [![CrewAI Getting Started Tutorial](https://img.youtube.com/vi/-kSOTtYzgEw/hqdefault.jpg)](https://www.youtube.com/watch?v=-kSOTtYzgEw "CrewAI Getting Started Tutorial") ### - Learning Resources + +Learning Resources Learn CrewAI through our comprehensive courses: @@ -141,6 +142,7 @@ CrewAI offers two powerful, complementary approaches that work seamlessly togeth - Dynamic task delegation and collaboration - Specialized roles with defined goals and expertise - Flexible problem-solving approaches + 2. **Flows**: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide: - Fine-grained control over execution paths for real-world scenarios @@ -187,6 +189,7 @@ If you encounter issues during installation or usage, here are some common solut - Install tiktoken explicitly: `uv pip install 'crewai[embeddings]'` - If using embedchain or other tools: `uv pip install 'crewai[tools]'` + 2. **Failed building wheel for tiktoken** - Ensure Rust compiler is installed (see installation steps above) @@ -270,7 +273,7 @@ reporting_analyst: **tasks.yaml** -```yaml +````yaml # src/my_project/config/tasks.yaml research_task: description: > @@ -290,7 +293,7 @@ reporting_task: Formatted as markdown without '```' agent: reporting_analyst output_file: report.md -``` +```` **crew.py** @@ -556,7 +559,7 @@ Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM- - **LangGraph**: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework's tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems. -*P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb)).* +_P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb))._ - **Autogen**: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows. - **ChatDev**: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications. @@ -674,9 +677,9 @@ CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/b ### Enterprise Features -- [What additional features does CrewAI AOP offer?](#q-what-additional-features-does-crewai-amp-offer) -- [Is CrewAI AOP available for cloud and on-premise deployments?](#q-is-crewai-amp-available-for-cloud-and-on-premise-deployments) -- [Can I try CrewAI AOP for free?](#q-can-i-try-crewai-amp-for-free) +- [What additional features does CrewAI AMP offer?](#q-what-additional-features-does-crewai-amp-offer) +- [Is CrewAI AMP available for cloud and on-premise deployments?](#q-is-crewai-amp-available-for-cloud-and-on-premise-deployments) +- [Can I try CrewAI AMP for free?](#q-can-i-try-crewai-amp-for-free) ### Q: What exactly is CrewAI? @@ -732,17 +735,17 @@ A: Check out practical examples in the [CrewAI-examples repository](https://gith A: Contributions are warmly welcomed! Fork the repository, create your branch, implement your changes, and submit a pull request. See the Contribution section of the README for detailed guidelines. -### Q: What additional features does CrewAI AOP offer? +### Q: What additional features does CrewAI AMP offer? -A: CrewAI AOP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support. +A: CrewAI AMP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support. -### Q: Is CrewAI AOP available for cloud and on-premise deployments? +### Q: Is CrewAI AMP available for cloud and on-premise deployments? -A: Yes, CrewAI AOP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements. +A: Yes, CrewAI AMP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements. -### Q: Can I try CrewAI AOP for free? +### Q: Can I try CrewAI AMP for free? -A: Yes, you can explore part of the CrewAI AOP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free. +A: Yes, you can explore part of the CrewAI AMP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free. ### Q: Does CrewAI support fine-tuning or training custom models? @@ -762,7 +765,7 @@ A: CrewAI is highly scalable, supporting simple automations and large-scale ente ### Q: Does CrewAI offer debugging and monitoring tools? -A: Yes, CrewAI AOP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations. +A: Yes, CrewAI AMP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations. ### Q: What programming languages does CrewAI support? diff --git a/docs/docs.json b/docs/docs.json index 29a35f1c2..d9e5762a1 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -329,7 +329,7 @@ ] }, { - "tab": "AOP", + "tab": "AMP", "icon": "briefcase", "groups": [ { @@ -759,7 +759,7 @@ ] }, { - "tab": "AOP", + "tab": "AMP", "icon": "briefcase", "groups": [ { diff --git a/docs/en/api-reference/introduction.mdx b/docs/en/api-reference/introduction.mdx index 5c4597721..45ccac71e 100644 --- a/docs/en/api-reference/introduction.mdx +++ b/docs/en/api-reference/introduction.mdx @@ -1,19 +1,19 @@ --- title: "Introduction" -description: "Complete reference for the CrewAI AOP REST API" +description: "Complete reference for the CrewAI AMP REST API" icon: "code" mode: "wide" --- -# CrewAI AOP API +# CrewAI AMP API -Welcome to the CrewAI AOP API reference. This API allows you to programmatically interact with your deployed crews, enabling integration with your applications, workflows, and services. +Welcome to the CrewAI AMP API reference. This API allows you to programmatically interact with your deployed crews, enabling integration with your applications, workflows, and services. ## Quick Start - Navigate to your crew's detail page in the CrewAI AOP dashboard and copy your Bearer Token from the Status tab. + Navigate to your crew's detail page in the CrewAI AMP dashboard and copy your Bearer Token from the Status tab. @@ -48,7 +48,7 @@ curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \ You can find both token types in the Status tab of your crew's detail page in - the CrewAI AOP dashboard. + the CrewAI AMP dashboard. ## Base URL @@ -84,7 +84,7 @@ The API uses standard HTTP status codes: ## Interactive Testing - **Why no "Send" button?** Since each CrewAI AOP user has their own unique crew + **Why no "Send" button?** Since each CrewAI AMP user has their own unique crew URL, we use **reference mode** instead of an interactive playground to avoid confusion. This shows you exactly what the requests should look like without non-functional send buttons. diff --git a/docs/en/concepts/agents.mdx b/docs/en/concepts/agents.mdx index e032e3f5f..5240c5a9f 100644 --- a/docs/en/concepts/agents.mdx +++ b/docs/en/concepts/agents.mdx @@ -8,6 +8,7 @@ mode: "wide" ## Overview of an Agent In the CrewAI framework, an `Agent` is an autonomous unit that can: + - Perform specific tasks - Make decisions based on its role and goal - Use tools to accomplish objectives @@ -16,15 +17,19 @@ In the CrewAI framework, an `Agent` is an autonomous unit that can: - Delegate tasks when allowed -Think of an agent as a specialized team member with specific skills, expertise, and responsibilities. For example, a `Researcher` agent might excel at gathering and analyzing information, while a `Writer` agent might be better at creating content. + Think of an agent as a specialized team member with specific skills, + expertise, and responsibilities. For example, a `Researcher` agent might excel + at gathering and analyzing information, while a `Writer` agent might be better + at creating content. -CrewAI AOP includes a Visual Agent Builder that simplifies agent creation and configuration without writing code. Design your agents visually and test them in real-time. +CrewAI AMP includes a Visual Agent Builder that simplifies agent creation and configuration without writing code. Design your agents visually and test them in real-time. ![Visual Agent Builder Screenshot](/images/enterprise/crew-studio-interface.png) The Visual Agent Builder enables: + - Intuitive agent configuration with form-based interfaces - Real-time testing and validation - Template library with pre-configured agent types @@ -33,36 +38,36 @@ The Visual Agent Builder enables: ## Agent Attributes -| Attribute | Parameter | Type | Description | -| :-------------------------------------- | :----------------------- | :---------------------------- | :------------------------------------------------------------------------------------------------------------------- | -| **Role** | `role` | `str` | Defines the agent's function and expertise within the crew. | -| **Goal** | `goal` | `str` | The individual objective that guides the agent's decision-making. | -| **Backstory** | `backstory` | `str` | Provides context and personality to the agent, enriching interactions. | -| **LLM** _(optional)_ | `llm` | `Union[str, LLM, Any]` | Language model that powers the agent. Defaults to the model specified in `OPENAI_MODEL_NAME` or "gpt-4". | -| **Tools** _(optional)_ | `tools` | `List[BaseTool]` | Capabilities or functions available to the agent. Defaults to an empty list. | -| **Function Calling LLM** _(optional)_ | `function_calling_llm` | `Optional[Any]` | Language model for tool calling, overrides crew's LLM if specified. | -| **Max Iterations** _(optional)_ | `max_iter` | `int` | Maximum iterations before the agent must provide its best answer. Default is 20. | -| **Max RPM** _(optional)_ | `max_rpm` | `Optional[int]` | Maximum requests per minute to avoid rate limits. | -| **Max Execution Time** _(optional)_ | `max_execution_time` | `Optional[int]` | Maximum time (in seconds) for task execution. | -| **Verbose** _(optional)_ | `verbose` | `bool` | Enable detailed execution logs for debugging. Default is False. | -| **Allow Delegation** _(optional)_ | `allow_delegation` | `bool` | Allow the agent to delegate tasks to other agents. Default is False. | -| **Step Callback** _(optional)_ | `step_callback` | `Optional[Any]` | Function called after each agent step, overrides crew callback. | -| **Cache** _(optional)_ | `cache` | `bool` | Enable caching for tool usage. Default is True. | -| **System Template** _(optional)_ | `system_template` | `Optional[str]` | Custom system prompt template for the agent. | -| **Prompt Template** _(optional)_ | `prompt_template` | `Optional[str]` | Custom prompt template for the agent. | -| **Response Template** _(optional)_ | `response_template` | `Optional[str]` | Custom response template for the agent. | -| **Allow Code Execution** _(optional)_ | `allow_code_execution` | `Optional[bool]` | Enable code execution for the agent. Default is False. | -| **Max Retry Limit** _(optional)_ | `max_retry_limit` | `int` | Maximum number of retries when an error occurs. Default is 2. | -| **Respect Context Window** _(optional)_ | `respect_context_window` | `bool` | Keep messages under context window size by summarizing. Default is True. | -| **Code Execution Mode** _(optional)_ | `code_execution_mode` | `Literal["safe", "unsafe"]` | Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct). Default is 'safe'. | -| **Multimodal** _(optional)_ | `multimodal` | `bool` | Whether the agent supports multimodal capabilities. Default is False. | -| **Inject Date** _(optional)_ | `inject_date` | `bool` | Whether to automatically inject the current date into tasks. Default is False. | -| **Date Format** _(optional)_ | `date_format` | `str` | Format string for date when inject_date is enabled. Default is "%Y-%m-%d" (ISO format). | -| **Reasoning** _(optional)_ | `reasoning` | `bool` | Whether the agent should reflect and create a plan before executing a task. Default is False. | -| **Max Reasoning Attempts** _(optional)_ | `max_reasoning_attempts` | `Optional[int]` | Maximum number of reasoning attempts before executing the task. If None, will try until ready. | -| **Embedder** _(optional)_ | `embedder` | `Optional[Dict[str, Any]]` | Configuration for the embedder used by the agent. | -| **Knowledge Sources** _(optional)_ | `knowledge_sources` | `Optional[List[BaseKnowledgeSource]]` | Knowledge sources available to the agent. | -| **Use System Prompt** _(optional)_ | `use_system_prompt` | `Optional[bool]` | Whether to use system prompt (for o1 model support). Default is True. | +| Attribute | Parameter | Type | Description | +| :-------------------------------------- | :----------------------- | :------------------------------------ | :------------------------------------------------------------------------------------------------------- | +| **Role** | `role` | `str` | Defines the agent's function and expertise within the crew. | +| **Goal** | `goal` | `str` | The individual objective that guides the agent's decision-making. | +| **Backstory** | `backstory` | `str` | Provides context and personality to the agent, enriching interactions. | +| **LLM** _(optional)_ | `llm` | `Union[str, LLM, Any]` | Language model that powers the agent. Defaults to the model specified in `OPENAI_MODEL_NAME` or "gpt-4". | +| **Tools** _(optional)_ | `tools` | `List[BaseTool]` | Capabilities or functions available to the agent. Defaults to an empty list. | +| **Function Calling LLM** _(optional)_ | `function_calling_llm` | `Optional[Any]` | Language model for tool calling, overrides crew's LLM if specified. | +| **Max Iterations** _(optional)_ | `max_iter` | `int` | Maximum iterations before the agent must provide its best answer. Default is 20. | +| **Max RPM** _(optional)_ | `max_rpm` | `Optional[int]` | Maximum requests per minute to avoid rate limits. | +| **Max Execution Time** _(optional)_ | `max_execution_time` | `Optional[int]` | Maximum time (in seconds) for task execution. | +| **Verbose** _(optional)_ | `verbose` | `bool` | Enable detailed execution logs for debugging. Default is False. | +| **Allow Delegation** _(optional)_ | `allow_delegation` | `bool` | Allow the agent to delegate tasks to other agents. Default is False. | +| **Step Callback** _(optional)_ | `step_callback` | `Optional[Any]` | Function called after each agent step, overrides crew callback. | +| **Cache** _(optional)_ | `cache` | `bool` | Enable caching for tool usage. Default is True. | +| **System Template** _(optional)_ | `system_template` | `Optional[str]` | Custom system prompt template for the agent. | +| **Prompt Template** _(optional)_ | `prompt_template` | `Optional[str]` | Custom prompt template for the agent. | +| **Response Template** _(optional)_ | `response_template` | `Optional[str]` | Custom response template for the agent. | +| **Allow Code Execution** _(optional)_ | `allow_code_execution` | `Optional[bool]` | Enable code execution for the agent. Default is False. | +| **Max Retry Limit** _(optional)_ | `max_retry_limit` | `int` | Maximum number of retries when an error occurs. Default is 2. | +| **Respect Context Window** _(optional)_ | `respect_context_window` | `bool` | Keep messages under context window size by summarizing. Default is True. | +| **Code Execution Mode** _(optional)_ | `code_execution_mode` | `Literal["safe", "unsafe"]` | Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct). Default is 'safe'. | +| **Multimodal** _(optional)_ | `multimodal` | `bool` | Whether the agent supports multimodal capabilities. Default is False. | +| **Inject Date** _(optional)_ | `inject_date` | `bool` | Whether to automatically inject the current date into tasks. Default is False. | +| **Date Format** _(optional)_ | `date_format` | `str` | Format string for date when inject_date is enabled. Default is "%Y-%m-%d" (ISO format). | +| **Reasoning** _(optional)_ | `reasoning` | `bool` | Whether the agent should reflect and create a plan before executing a task. Default is False. | +| **Max Reasoning Attempts** _(optional)_ | `max_reasoning_attempts` | `Optional[int]` | Maximum number of reasoning attempts before executing the task. If None, will try until ready. | +| **Embedder** _(optional)_ | `embedder` | `Optional[Dict[str, Any]]` | Configuration for the embedder used by the agent. | +| **Knowledge Sources** _(optional)_ | `knowledge_sources` | `Optional[List[BaseKnowledgeSource]]` | Knowledge sources available to the agent. | +| **Use System Prompt** _(optional)_ | `use_system_prompt` | `Optional[bool]` | Whether to use system prompt (for o1 model support). Default is True. | ## Creating Agents @@ -137,7 +142,8 @@ class LatestAiDevelopmentCrew(): ``` -The names you use in your YAML files (`agents.yaml`) should match the method names in your Python code. + The names you use in your YAML files (`agents.yaml`) should match the method + names in your Python code. ### Direct Code Definition @@ -184,6 +190,7 @@ agent = Agent( Let's break down some key parameter combinations for common use cases: #### Basic Research Agent + ```python Code research_agent = Agent( role="Research Analyst", @@ -195,6 +202,7 @@ research_agent = Agent( ``` #### Code Development Agent + ```python Code dev_agent = Agent( role="Senior Python Developer", @@ -208,6 +216,7 @@ dev_agent = Agent( ``` #### Long-Running Analysis Agent + ```python Code analysis_agent = Agent( role="Data Analyst", @@ -221,6 +230,7 @@ analysis_agent = Agent( ``` #### Custom Template Agent + ```python Code custom_agent = Agent( role="Customer Service Representative", @@ -236,6 +246,7 @@ custom_agent = Agent( ``` #### Date-Aware Agent with Reasoning + ```python Code strategic_agent = Agent( role="Market Analyst", @@ -250,6 +261,7 @@ strategic_agent = Agent( ``` #### Reasoning Agent + ```python Code reasoning_agent = Agent( role="Strategic Planner", @@ -263,6 +275,7 @@ reasoning_agent = Agent( ``` #### Multimodal Agent + ```python Code multimodal_agent = Agent( role="Visual Content Analyst", @@ -276,52 +289,64 @@ multimodal_agent = Agent( ### Parameter Details #### Critical Parameters + - `role`, `goal`, and `backstory` are required and shape the agent's behavior - `llm` determines the language model used (default: OpenAI's GPT-4) #### Memory and Context + - `memory`: Enable to maintain conversation history - `respect_context_window`: Prevents token limit issues - `knowledge_sources`: Add domain-specific knowledge bases #### Execution Control + - `max_iter`: Maximum attempts before giving best answer - `max_execution_time`: Timeout in seconds - `max_rpm`: Rate limiting for API calls - `max_retry_limit`: Retries on error #### Code Execution + - `allow_code_execution`: Must be True to run code - `code_execution_mode`: - `"safe"`: Uses Docker (recommended for production) - `"unsafe"`: Direct execution (use only in trusted environments) - This runs a default Docker image. If you want to configure the docker image, the checkout the Code Interpreter Tool in the tools section. - Add the code interpreter tool as a tool in the agent as a tool parameter. - + This runs a default Docker image. If you want to configure the docker image, + the checkout the Code Interpreter Tool in the tools section. Add the code + interpreter tool as a tool in the agent as a tool parameter. + #### Advanced Features + - `multimodal`: Enable multimodal capabilities for processing text and visual content - `reasoning`: Enable agent to reflect and create plans before executing tasks - `inject_date`: Automatically inject current date into task descriptions #### Templates + - `system_template`: Defines agent's core behavior - `prompt_template`: Structures input format - `response_template`: Formats agent responses -When using custom templates, ensure that both `system_template` and `prompt_template` are defined. The `response_template` is optional but recommended for consistent output formatting. + When using custom templates, ensure that both `system_template` and + `prompt_template` are defined. The `response_template` is optional but + recommended for consistent output formatting. -When using custom templates, you can use variables like `{role}`, `{goal}`, and `{backstory}` in your templates. These will be automatically populated during execution. + When using custom templates, you can use variables like `{role}`, `{goal}`, + and `{backstory}` in your templates. These will be automatically populated + during execution. ## Agent Tools Agents can be equipped with various tools to enhance their capabilities. CrewAI supports tools from: + - [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) - [LangChain Tools](https://python.langchain.com/docs/integrations/tools) @@ -360,7 +385,8 @@ analyst = Agent( ``` -When `memory` is enabled, the agent will maintain context across multiple interactions, improving its ability to handle complex, multi-step tasks. + When `memory` is enabled, the agent will maintain context across multiple + interactions, improving its ability to handle complex, multi-step tasks. ## Context Window Management @@ -390,6 +416,7 @@ smart_agent = Agent( ``` **What happens when context limits are exceeded:** + - ⚠️ **Warning message**: `"Context length exceeded. Summarizing content to fit the model context window."` - 🔄 **Automatic summarization**: CrewAI intelligently summarizes the conversation history - ✅ **Continued execution**: Task execution continues seamlessly with the summarized context @@ -411,6 +438,7 @@ strict_agent = Agent( ``` **What happens when context limits are exceeded:** + - ❌ **Error message**: `"Context length exceeded. Consider using smaller text or RAG tools from crewai_tools."` - 🛑 **Execution stops**: Task execution halts immediately - 🔧 **Manual intervention required**: You need to modify your approach @@ -418,6 +446,7 @@ strict_agent = Agent( ### Choosing the Right Setting #### Use `respect_context_window=True` (Default) when: + - **Processing large documents** that might exceed context limits - **Long-running conversations** where some summarization is acceptable - **Research tasks** where general context is more important than exact details @@ -436,6 +465,7 @@ document_processor = Agent( ``` #### Use `respect_context_window=False` when: + - **Precision is critical** and information loss is unacceptable - **Legal or medical tasks** requiring complete context - **Code review** where missing details could introduce bugs @@ -458,6 +488,7 @@ precision_agent = Agent( When dealing with very large datasets, consider these strategies: #### 1. Use RAG Tools + ```python Code from crewai_tools import RagTool @@ -475,6 +506,7 @@ rag_agent = Agent( ``` #### 2. Use Knowledge Sources + ```python Code # Use knowledge sources instead of large prompts knowledge_agent = Agent( @@ -498,6 +530,7 @@ knowledge_agent = Agent( ### Troubleshooting Context Issues **If you're getting context limit errors:** + ```python Code # Quick fix: Enable automatic handling agent.respect_context_window = True @@ -511,6 +544,7 @@ agent.tools = [RagTool()] ``` **If automatic summarization loses important information:** + ```python Code # Disable auto-summarization and use RAG instead agent = Agent( @@ -524,7 +558,10 @@ agent = Agent( ``` -The context window management feature works automatically in the background. You don't need to call any special functions - just set `respect_context_window` to your preferred behavior and CrewAI handles the rest! + The context window management feature works automatically in the background. + You don't need to call any special functions - just set + `respect_context_window` to your preferred behavior and CrewAI handles the + rest! ## Direct Agent Interaction with `kickoff()` @@ -556,10 +593,10 @@ print(result.raw) ### Parameters and Return Values -| Parameter | Type | Description | -| :---------------- | :---------------------------------- | :------------------------------------------------------------------------ | -| `messages` | `Union[str, List[Dict[str, str]]]` | Either a string query or a list of message dictionaries with role/content | -| `response_format` | `Optional[Type[Any]]` | Optional Pydantic model for structured output | +| Parameter | Type | Description | +| :---------------- | :--------------------------------- | :------------------------------------------------------------------------ | +| `messages` | `Union[str, List[Dict[str, str]]]` | Either a string query or a list of message dictionaries with role/content | +| `response_format` | `Optional[Type[Any]]` | Optional Pydantic model for structured output | The method returns a `LiteAgentOutput` object with the following properties: @@ -621,28 +658,34 @@ asyncio.run(main()) ``` -The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler execution flow while preserving all of the agent's configuration (role, goal, backstory, tools, etc.). + The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler + execution flow while preserving all of the agent's configuration (role, goal, + backstory, tools, etc.). ## Important Considerations and Best Practices ### Security and Code Execution + - When using `allow_code_execution`, be cautious with user input and always validate it - Use `code_execution_mode: "safe"` (Docker) in production environments - Consider setting appropriate `max_execution_time` limits to prevent infinite loops ### Performance Optimization + - Use `respect_context_window: true` to prevent token limit issues - Set appropriate `max_rpm` to avoid rate limiting - Enable `cache: true` to improve performance for repetitive tasks - Adjust `max_iter` and `max_retry_limit` based on task complexity ### Memory and Context Management + - Leverage `knowledge_sources` for domain-specific information - Configure `embedder` when using custom embedding models - Use custom templates (`system_template`, `prompt_template`, `response_template`) for fine-grained control over agent behavior ### Advanced Features + - Enable `reasoning: true` for agents that need to plan and reflect before executing complex tasks - Set appropriate `max_reasoning_attempts` to control planning iterations (None for unlimited attempts) - Use `inject_date: true` to provide agents with current date awareness for time-sensitive tasks @@ -650,6 +693,7 @@ The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler e - Enable `multimodal: true` for agents that need to process both text and visual content ### Agent Collaboration + - Enable `allow_delegation: true` when agents need to work together - Use `step_callback` to monitor and log agent interactions - Consider using different LLMs for different purposes: @@ -657,6 +701,7 @@ The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler e - `function_calling_llm` for efficient tool usage ### Date Awareness and Reasoning + - Use `inject_date: true` to provide agents with current date awareness for time-sensitive tasks - Customize the date format with `date_format` using standard Python datetime format codes - Valid format codes include: %Y (year), %m (month), %d (day), %B (full month name), etc. @@ -664,22 +709,26 @@ The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler e - Enable `reasoning: true` for complex tasks that benefit from upfront planning and reflection ### Model Compatibility + - Set `use_system_prompt: false` for older models that don't support system messages - Ensure your chosen `llm` supports the features you need (like function calling) ## Troubleshooting Common Issues 1. **Rate Limiting**: If you're hitting API rate limits: + - Implement appropriate `max_rpm` - Use caching for repetitive operations - Consider batching requests 2. **Context Window Errors**: If you're exceeding context limits: + - Enable `respect_context_window` - Use more efficient prompts - Clear agent memory periodically 3. **Code Execution Issues**: If code execution fails: + - Verify Docker is installed for safe mode - Check execution permissions - Review code sandbox settings diff --git a/docs/en/concepts/cli.mdx b/docs/en/concepts/cli.mdx index 7493faca5..5c507f614 100644 --- a/docs/en/concepts/cli.mdx +++ b/docs/en/concepts/cli.mdx @@ -5,7 +5,12 @@ icon: terminal mode: "wide" --- -Since release 0.140.0, CrewAI AOP started a process of migrating their login provider. As such, the authentication flow via CLI was updated. Users that use Google to login, or that created their account after July 3rd, 2025 will be unable to log in with older versions of the `crewai` library. + + Since release 0.140.0, CrewAI AMP started a process of migrating their login + provider. As such, the authentication flow via CLI was updated. Users that use + Google to login, or that created their account after July 3rd, 2025 will be + unable to log in with older versions of the `crewai` library. + ## Overview @@ -41,6 +46,7 @@ crewai create [OPTIONS] TYPE NAME - `NAME`: Name of the crew or flow Example: + ```shell Terminal crewai create crew my_new_crew crewai create flow my_new_flow @@ -57,6 +63,7 @@ crewai version [OPTIONS] - `--tools`: (Optional) Show the installed version of CrewAI tools Example: + ```shell Terminal crewai version crewai version --tools @@ -74,6 +81,7 @@ crewai train [OPTIONS] - `-f, --filename TEXT`: Path to a custom file for training (default: "trained_agents_data.pkl") Example: + ```shell Terminal crewai train -n 10 -f my_training_data.pkl ``` @@ -89,6 +97,7 @@ crewai replay [OPTIONS] - `-t, --task_id TEXT`: Replay the crew from this task ID, including all subsequent tasks Example: + ```shell Terminal crewai replay -t task_123456 ``` @@ -118,6 +127,7 @@ crewai reset-memories [OPTIONS] - `-a, --all`: Reset ALL memories Example: + ```shell Terminal crewai reset-memories --long --short crewai reset-memories --all @@ -135,6 +145,7 @@ crewai test [OPTIONS] - `-m, --model TEXT`: LLM Model to run the tests on the Crew (default: "gpt-4o-mini") Example: + ```shell Terminal crewai test -n 5 -m gpt-3.5-turbo ``` @@ -148,12 +159,16 @@ crewai run ``` -Starting from version 0.103.0, the `crewai run` command can be used to run both standard crews and flows. For flows, it automatically detects the type from pyproject.toml and runs the appropriate command. This is now the recommended way to run both crews and flows. + Starting from version 0.103.0, the `crewai run` command can be used to run + both standard crews and flows. For flows, it automatically detects the type + from pyproject.toml and runs the appropriate command. This is now the + recommended way to run both crews and flows. -Make sure to run these commands from the directory where your CrewAI project is set up. -Some commands may require additional configuration or setup within your project structure. + Make sure to run these commands from the directory where your CrewAI project + is set up. Some commands may require additional configuration or setup within + your project structure. ### 9. Chat @@ -165,6 +180,7 @@ After receiving the results, you can continue interacting with the assistant for ```shell Terminal crewai chat ``` + Ensure you execute these commands from your CrewAI project's root directory. @@ -182,28 +198,30 @@ def crew(self) -> Crew: chat_llm="gpt-4o", # LLM for chat orchestration ) ``` + ### 10. Deploy -Deploy the crew or flow to [CrewAI AOP](https://app.crewai.com). +Deploy the crew or flow to [CrewAI AMP](https://app.crewai.com). -- **Authentication**: You need to be authenticated to deploy to CrewAI AOP. - You can login or create an account with: - ```shell Terminal - crewai login - ``` +- **Authentication**: You need to be authenticated to deploy to CrewAI AMP. + You can login or create an account with: + + ```shell Terminal + crewai login + ``` - **Create a deployment**: Once you are authenticated, you can create a deployment for your crew or flow from the root of your localproject. - ```shell Terminal - crewai deploy create - ``` - - Reads your local project configuration. - - Prompts you to confirm the environment variables (like `OPENAI_API_KEY`, `SERPER_API_KEY`) found locally. These will be securely stored with the deployment on the Enterprise platform. Ensure your sensitive keys are correctly configured locally (e.g., in a `.env` file) before running this. + ```shell Terminal + crewai deploy create + ``` + - Reads your local project configuration. + - Prompts you to confirm the environment variables (like `OPENAI_API_KEY`, `SERPER_API_KEY`) found locally. These will be securely stored with the deployment on the Enterprise platform. Ensure your sensitive keys are correctly configured locally (e.g., in a `.env` file) before running this. ### 11. Organization Management -Manage your CrewAI AOP organizations. +Manage your CrewAI AMP organizations. ```shell Terminal crewai org [COMMAND] [OPTIONS] @@ -212,65 +230,80 @@ crewai org [COMMAND] [OPTIONS] #### Commands: - `list`: List all organizations you belong to + ```shell Terminal crewai org list ``` - `current`: Display your currently active organization + ```shell Terminal crewai org current ``` - `switch`: Switch to a specific organization + ```shell Terminal crewai org switch ``` -You must be authenticated to CrewAI AOP to use these organization management commands. + You must be authenticated to CrewAI AMP to use these organization management + commands. - **Create a deployment** (continued): - - Links the deployment to the corresponding remote GitHub repository (it usually detects this automatically). -- **Deploy the Crew**: Once you are authenticated, you can deploy your crew or flow to CrewAI AOP. - ```shell Terminal - crewai deploy push - ``` - - Initiates the deployment process on the CrewAI AOP platform. - - Upon successful initiation, it will output the Deployment created successfully! message along with the Deployment Name and a unique Deployment ID (UUID). + - Links the deployment to the corresponding remote GitHub repository (it usually detects this automatically). + +- **Deploy the Crew**: Once you are authenticated, you can deploy your crew or flow to CrewAI AMP. + + ```shell Terminal + crewai deploy push + ``` + + - Initiates the deployment process on the CrewAI AMP platform. + - Upon successful initiation, it will output the Deployment created successfully! message along with the Deployment Name and a unique Deployment ID (UUID). - **Deployment Status**: You can check the status of your deployment with: - ```shell Terminal - crewai deploy status - ``` - This fetches the latest deployment status of your most recent deployment attempt (e.g., `Building Images for Crew`, `Deploy Enqueued`, `Online`). + + ```shell Terminal + crewai deploy status + ``` + + This fetches the latest deployment status of your most recent deployment attempt (e.g., `Building Images for Crew`, `Deploy Enqueued`, `Online`). - **Deployment Logs**: You can check the logs of your deployment with: - ```shell Terminal - crewai deploy logs - ``` - This streams the deployment logs to your terminal. + + ```shell Terminal + crewai deploy logs + ``` + + This streams the deployment logs to your terminal. - **List deployments**: You can list all your deployments with: - ```shell Terminal - crewai deploy list - ``` - This lists all your deployments. + + ```shell Terminal + crewai deploy list + ``` + + This lists all your deployments. - **Delete a deployment**: You can delete a deployment with: - ```shell Terminal - crewai deploy remove - ``` - This deletes the deployment from the CrewAI AOP platform. + + ```shell Terminal + crewai deploy remove + ``` + + This deletes the deployment from the CrewAI AMP platform. - **Help Command**: You can get help with the CLI with: - ```shell Terminal - crewai deploy --help - ``` - This shows the help message for the CrewAI Deploy CLI. + ```shell Terminal + crewai deploy --help + ``` + This shows the help message for the CrewAI Deploy CLI. -Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI AOP](http://app.crewai.com) using the CLI. +Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI AMP](http://app.crewai.com) using the CLI. ## Text Tutorial + **Python Version Requirements** - CrewAI requires `Python >=3.10 and <3.14`. Here's how to check your version: - ```bash - python3 --version - ``` +CrewAI requires `Python >=3.10 and <3.14`. Here's how to check your version: + +```bash +python3 --version +``` + +If you need to update Python, visit [python.org/downloads](https://python.org/downloads) - If you need to update Python, visit [python.org/downloads](https://python.org/downloads) **OpenAI SDK Requirement** - CrewAI 0.175.0 requires `openai >= 1.13.3`. If you manage dependencies yourself, ensure your environment satisfies this constraint to avoid import/runtime issues. +CrewAI 0.175.0 requires `openai >= 1.13.3`. If you manage dependencies yourself, ensure your environment satisfies this constraint to avoid import/runtime issues. + CrewAI uses the `uv` as its dependency management and package handling tool. It simplifies project setup and execution, offering a seamless experience. @@ -95,6 +100,7 @@ If you haven't installed `uv` yet, follow **step 1** to quickly get it set up on ``` Installation successful! You're ready to create your first crew! 🎉 + # Creating a CrewAI Project @@ -128,6 +134,7 @@ We recommend using the `YAML` template scaffolding for a structured approach to ├── agents.yaml └── tasks.yaml ``` + @@ -144,6 +151,7 @@ We recommend using the `YAML` template scaffolding for a structured approach to - Start by editing `agents.yaml` and `tasks.yaml` to define your crew's behavior. - Keep sensitive information like API keys in `.env`. + @@ -167,13 +175,15 @@ We recommend using the `YAML` template scaffolding for a structured approach to For teams and organizations, CrewAI offers enterprise deployment options that eliminate setup complexity: -### CrewAI AOP (SaaS) +### CrewAI AMP (SaaS) + - Zero installation required - just sign up for free at [app.crewai.com](https://app.crewai.com) - Automatic updates and maintenance - Managed infrastructure and scaling - Build Crews with no Code ### CrewAI Factory (Self-hosted) + - Containerized deployment for your infrastructure - Supports any hyperscaler including on prem deployments - Integration with your existing security systems @@ -186,12 +196,9 @@ For teams and organizations, CrewAI offers enterprise deployment options that el ## Next Steps - - Follow our quickstart guide to create your first CrewAI agent and get hands-on experience. + + Follow our quickstart guide to create your first CrewAI agent and get + hands-on experience. -This guide focuses on strategic thinking rather than specific model recommendations, as the LLM landscape evolves rapidly. + This guide focuses on strategic thinking rather than specific model + recommendations, as the LLM landscape evolves rapidly. ## Quick Decision Framework - Begin by deeply understanding what your tasks actually require. Consider the cognitive complexity involved, the depth of reasoning needed, the format of expected outputs, and the amount of context the model will need to process. This foundational analysis will guide every subsequent decision. + Begin by deeply understanding what your tasks actually require. Consider the + cognitive complexity involved, the depth of reasoning needed, the format of + expected outputs, and the amount of context the model will need to process. + This foundational analysis will guide every subsequent decision. - Once you understand your requirements, map them to model strengths. Different model families excel at different types of work; some are optimized for reasoning and analysis, others for creativity and content generation, and others for speed and efficiency. + Once you understand your requirements, map them to model strengths. + Different model families excel at different types of work; some are + optimized for reasoning and analysis, others for creativity and content + generation, and others for speed and efficiency. - Factor in your real-world operational constraints including budget limitations, latency requirements, data privacy needs, and infrastructure capabilities. The theoretically best model may not be the practically best choice for your situation. + Factor in your real-world operational constraints including budget + limitations, latency requirements, data privacy needs, and infrastructure + capabilities. The theoretically best model may not be the practically best + choice for your situation. - Start with reliable, well-understood models and optimize based on actual performance in your specific use case. Real-world results often differ from theoretical benchmarks, so empirical testing is crucial. + Start with reliable, well-understood models and optimize based on actual + performance in your specific use case. Real-world results often differ from + theoretical benchmarks, so empirical testing is crucial. @@ -43,6 +55,7 @@ The most critical step in LLM selection is understanding what your task actually - **Complex Tasks** require multi-step reasoning, strategic thinking, and the ability to handle ambiguous or incomplete information. These might involve analyzing multiple data sources, developing comprehensive strategies, or solving problems that require breaking down into smaller components. The model needs to maintain context across multiple reasoning steps and often must make inferences that aren't explicitly stated. - **Creative Tasks** demand a different type of cognitive capability focused on generating novel, engaging, and contextually appropriate content. This includes storytelling, marketing copy creation, and creative problem-solving. The model needs to understand nuance, tone, and audience while producing content that feels authentic and engaging rather than formulaic. + @@ -51,6 +64,7 @@ The most critical step in LLM selection is understanding what your task actually - **Creative Content** outputs demand a balance of technical competence and creative flair. The model needs to understand audience, tone, and brand voice while producing content that engages readers and achieves specific communication goals. Quality here is often subjective and requires models that can adapt their writing style to different contexts and purposes. - **Technical Content** sits between structured data and creative content, requiring both precision and clarity. Documentation, code generation, and technical analysis need to be accurate and comprehensive while remaining accessible to the intended audience. The model must understand complex technical concepts and communicate them effectively. + @@ -59,6 +73,7 @@ The most critical step in LLM selection is understanding what your task actually - **Long Context** requirements emerge when working with substantial documents, extended conversations, or complex multi-part tasks. The model needs to maintain coherence across thousands of tokens while referencing earlier information accurately. This capability becomes crucial for document analysis, comprehensive research, and sophisticated dialogue systems. - **Very Long Context** scenarios push the boundaries of what's currently possible, involving massive document processing, extensive research synthesis, or complex multi-session interactions. These use cases require models specifically designed for extended context handling and often involve trade-offs between context length and processing speed. + @@ -73,6 +88,7 @@ Understanding model capabilities requires looking beyond marketing claims and be The strength of reasoning models lies in their ability to maintain logical consistency across extended reasoning chains and to break down complex problems into manageable components. They're particularly valuable for strategic planning, complex analysis, and situations where the quality of reasoning matters more than speed of response. However, reasoning models often come with trade-offs in terms of speed and cost. They may also be less suitable for creative tasks or simple operations where their sophisticated reasoning capabilities aren't needed. Consider these models when your tasks involve genuine complexity that benefits from systematic, step-by-step analysis. + @@ -81,6 +97,7 @@ Understanding model capabilities requires looking beyond marketing claims and be The primary advantage of general purpose models is their reliability and predictability across different types of work. They handle most standard business tasks competently, from research and analysis to content creation and data processing. This makes them excellent choices for teams that need consistent performance across varied workflows. While general purpose models may not achieve the peak performance of specialized alternatives in specific domains, they offer operational simplicity and reduced complexity in model management. They're often the best starting point for new projects, allowing teams to understand their specific needs before potentially optimizing with more specialized models. + @@ -89,6 +106,7 @@ Understanding model capabilities requires looking beyond marketing claims and be These models excel in scenarios involving routine operations, simple data processing, function calling, and high-volume tasks where the cognitive requirements are relatively straightforward. They're particularly valuable for applications that need to process many requests quickly or operate within tight budget constraints. The key consideration with efficient models is ensuring that their capabilities align with your task requirements. While they can handle many routine operations effectively, they may struggle with tasks requiring nuanced understanding, complex reasoning, or sophisticated content generation. They're best used for well-defined, routine operations where speed and cost matter more than sophistication. + @@ -97,6 +115,7 @@ Understanding model capabilities requires looking beyond marketing claims and be The strength of creative models lies in their ability to adapt writing style to different audiences, maintain consistent voice and tone, and generate content that engages readers effectively. They often perform better on tasks involving storytelling, marketing copy, brand communications, and other content where creativity and engagement are primary goals. When selecting creative models, consider not just their ability to generate text, but their understanding of audience, context, and purpose. The best creative models can adapt their output to match specific brand voices, target different audience segments, and maintain consistency across extended content pieces. + @@ -105,6 +124,7 @@ Understanding model capabilities requires looking beyond marketing claims and be The primary benefits of open source models include elimination of per-token costs, ability to fine-tune for specific use cases, complete data privacy, and independence from external API providers. They're particularly valuable for organizations with strict data privacy requirements, budget constraints, or specific customization needs. However, open source models require more technical expertise to deploy and maintain effectively. Teams need to consider infrastructure costs, model management complexity, and the ongoing effort required to keep models updated and optimized. The total cost of ownership may be higher than cloud-based alternatives when factoring in technical overhead. + @@ -113,7 +133,8 @@ Understanding model capabilities requires looking beyond marketing claims and be ### a. Multi-Model Approach -Use different models for different purposes within the same crew to optimize both performance and cost. + Use different models for different purposes within the same crew to optimize + both performance and cost. The most sophisticated CrewAI implementations often employ multiple models strategically, assigning different models to different agents based on their specific roles and requirements. This approach allows teams to optimize for both performance and cost by using the most appropriate model for each type of work. @@ -177,6 +198,7 @@ The key to successful multi-model implementation is understanding how different Effective manager LLMs require strong reasoning capabilities to make good delegation decisions, consistent performance to ensure predictable coordination, and excellent context management to track the state of multiple agents simultaneously. The model needs to understand the capabilities and limitations of different agents while optimizing task allocation for efficiency and quality. Cost considerations are particularly important for manager LLMs since they're involved in every operation. The model needs to provide sufficient capability for effective coordination while remaining cost-effective for frequent use. This often means finding models that offer good reasoning capabilities without the premium pricing of the most sophisticated options. + @@ -185,6 +207,7 @@ The key to successful multi-model implementation is understanding how different The most important characteristics for function calling LLMs are precision and reliability rather than creativity or sophisticated reasoning. The model needs to consistently extract the correct parameters from natural language requests and handle tool responses appropriately. Speed is also important since tool usage often involves multiple round trips that can impact overall performance. Many teams find that specialized function calling models or general purpose models with strong tool support work better than creative or reasoning-focused models for this role. The key is ensuring that the model can reliably bridge the gap between natural language instructions and structured tool calls. + @@ -193,6 +216,7 @@ The key to successful multi-model implementation is understanding how different Consider agent-specific overrides when an agent's role requires capabilities that differ substantially from other crew members. For example, a creative writing agent might benefit from a model optimized for content generation, while a data analysis agent might perform better with a reasoning-focused model. The challenge with agent-specific overrides is balancing optimization with operational complexity. Each additional model adds complexity to deployment, monitoring, and cost management. Teams should focus overrides on agents where the performance improvement justifies the additional complexity. + @@ -209,6 +233,7 @@ Effective task definition is often more important than model selection in determ Effective task descriptions include relevant context and constraints that help the agent understand the broader purpose and any limitations they need to work within. They break complex work into focused steps that can be executed systematically, rather than presenting overwhelming, multi-faceted objectives that are difficult to approach systematically. Common mistakes include being too vague about objectives, failing to provide necessary context, setting unclear success criteria, or combining multiple unrelated tasks into a single description. The goal is to provide enough information for the agent to succeed while maintaining focus on a single, clear objective. + @@ -217,6 +242,7 @@ Effective task definition is often more important than model selection in determ The best output guidelines provide concrete examples of quality indicators and define completion criteria clearly enough that both the agent and human reviewers can assess whether the task has been completed successfully. This reduces ambiguity and helps ensure consistent results across multiple task executions. Avoid generic output descriptions that could apply to any task, missing format specifications that leave agents guessing about structure, unclear quality standards that make evaluation difficult, or failing to provide examples or templates that help agents understand expectations. + @@ -229,6 +255,7 @@ Effective task definition is often more important than model selection in determ Implementing sequential dependencies effectively requires using the context parameter to chain related tasks, building complexity gradually through task progression, and ensuring that each task produces outputs that serve as meaningful inputs for subsequent tasks. The goal is to maintain logical flow between dependent tasks while avoiding unnecessary bottlenecks. Sequential dependencies work best when there's a clear logical progression from one task to another and when the output of one task genuinely improves the quality or feasibility of subsequent tasks. However, they can create bottlenecks if not managed carefully, so it's important to identify which dependencies are truly necessary versus those that are merely convenient. + @@ -237,6 +264,7 @@ Effective task definition is often more important than model selection in determ Successful parallel execution requires identifying tasks that can truly run independently, grouping related but separate work streams effectively, and planning for result integration when parallel tasks need to be combined into a final deliverable. The key is ensuring that parallel tasks don't create conflicts or redundancies that reduce overall quality. Consider parallel execution when you have multiple independent research streams, different types of analysis that don't depend on each other, or content creation tasks that can be developed simultaneously. However, be mindful of resource allocation and ensure that parallel execution doesn't overwhelm your available model capacity or budget. + @@ -245,7 +273,8 @@ Effective task definition is often more important than model selection in determ ### a. Role-Driven LLM Selection -Generic agent roles make it impossible to select the right LLM. Specific roles enable targeted model optimization. + Generic agent roles make it impossible to select the right LLM. Specific roles + enable targeted model optimization. The specificity of your agent roles directly determines which LLM capabilities matter most for optimal performance. This creates a strategic opportunity to match precise model strengths with agent responsibilities. @@ -253,6 +282,7 @@ The specificity of your agent roles directly determines which LLM capabilities m **Generic vs. Specific Role Impact on LLM Choice:** When defining roles, think about the specific domain knowledge, working style, and decision-making frameworks that would be most valuable for the tasks the agent will handle. The more specific and contextual the role definition, the better the model can embody that role effectively. + ```python # ✅ Specific role - clear LLM requirements specific_agent = Agent( @@ -273,7 +303,8 @@ specific_agent = Agent( ### b. Backstory as Model Context Amplifier -Strategic backstories multiply your chosen LLM's effectiveness by providing domain-specific context that generic prompting cannot achieve. + Strategic backstories multiply your chosen LLM's effectiveness by providing + domain-specific context that generic prompting cannot achieve. A well-crafted backstory transforms your LLM choice from generic capability to specialized expertise. This is especially crucial for cost optimization - a well-contextualized efficient model can outperform a premium model without proper context. @@ -300,6 +331,7 @@ domain_expert = Agent( ``` **Backstory Elements That Enhance LLM Performance:** + - **Domain Experience**: "10+ years in enterprise SaaS sales" - **Specific Expertise**: "Specializes in technical due diligence for Series B+ rounds" - **Working Style**: "Prefers data-driven decisions with clear documentation" @@ -332,6 +364,7 @@ tech_writer = Agent( ``` **Alignment Checklist:** + - ✅ **Role Specificity**: Clear domain and responsibilities - ✅ **LLM Match**: Model strengths align with role requirements - ✅ **Backstory Depth**: Provides domain context the LLM can leverage @@ -353,6 +386,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i - Are any agents heavily tool-dependent? **Action**: Document current agent roles and identify optimization opportunities. + @@ -369,6 +403,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i ``` **Action**: Establish your crew's default LLM before optimizing individual agents. + @@ -390,16 +425,18 @@ Rather than repeating the strategic framework, here's a tactical checklist for i ``` **Action**: Upgrade 20% of your agents that handle 80% of the complexity. + **Once you deploy your agents to production:** - - Use [CrewAI AOP platform](https://app.crewai.com) to A/B test your model selections + - Use [CrewAI AMP platform](https://app.crewai.com) to A/B test your model selections - Run multiple iterations with real inputs to measure consistency and performance - Compare cost vs. performance across your optimized setup - Share results with your team for collaborative decision-making **Action**: Replace guesswork with data-driven validation using the testing platform. + @@ -412,6 +449,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i Consider reasoning models for business strategy development, complex data analysis that requires drawing insights from multiple sources, multi-step problem solving where each step depends on previous analysis, and strategic planning tasks that require considering multiple variables and their interactions. However, reasoning models often come with higher costs and slower response times, so they're best reserved for tasks where their sophisticated capabilities provide genuine value rather than being used for simple operations that don't require complex reasoning. + @@ -420,6 +458,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i Use creative models for blog post writing and article creation, marketing copy that needs to engage and persuade, creative storytelling and narrative development, and brand communications where voice and tone are crucial. These models often understand nuance and context better than general purpose alternatives. Creative models may be less suitable for technical or analytical tasks where precision and factual accuracy are more important than engagement and style. They're best used when the creative and communicative aspects of the output are primary success factors. + @@ -428,6 +467,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i Consider efficient models for data processing and transformation tasks, simple formatting and organization operations, function calling and tool usage where precision matters more than sophistication, and high-volume operations where cost per operation is a significant factor. The key with efficient models is ensuring that their capabilities align with task requirements. They can handle many routine operations effectively but may struggle with tasks requiring nuanced understanding, complex reasoning, or sophisticated content generation. + @@ -436,6 +476,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i Consider open source models for internal company tools where data privacy is paramount, privacy-sensitive applications that can't use external APIs, cost-optimized deployments where per-token pricing is prohibitive, and situations requiring custom model modifications or fine-tuning. However, open source models require more technical expertise to deploy and maintain effectively. Consider the total cost of ownership including infrastructure, technical overhead, and ongoing maintenance when evaluating open source options. + @@ -455,6 +496,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i # Processing agent gets efficient model processor = Agent(role="Data Processor", llm=LLM(model="gpt-4o-mini")) ``` + @@ -474,6 +516,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i # Agents inherit crew LLM unless specifically overridden agent1 = Agent(llm=LLM(model="claude-3-5-sonnet")) # Override for specific needs ``` + @@ -492,6 +535,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i llm=LLM(model="claude-3-5-sonnet") # Also strong with tools ) ``` + @@ -507,6 +551,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i # Test performance, then optimize specific agents as needed # Use Enterprise platform testing to validate improvements ``` + @@ -515,6 +560,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i **Real Example**: Using a short-context model for agents that need to maintain conversation history across multiple task iterations, or in crews with extensive agent-to-agent communication. **CrewAI Solution**: Match context capabilities to crew communication patterns. + @@ -522,26 +568,40 @@ Rather than repeating the strategic framework, here's a tactical checklist for i - Begin with reliable, general-purpose models that are well-understood and widely supported. This provides a stable foundation for understanding your specific requirements and performance expectations before optimizing for specialized needs. + Begin with reliable, general-purpose models that are well-understood and + widely supported. This provides a stable foundation for understanding your + specific requirements and performance expectations before optimizing for + specialized needs. - Develop metrics that align with your specific use case and business requirements rather than relying solely on general benchmarks. Focus on measuring outcomes that directly impact your success rather than theoretical performance indicators. + Develop metrics that align with your specific use case and business + requirements rather than relying solely on general benchmarks. Focus on + measuring outcomes that directly impact your success rather than theoretical + performance indicators. - Make model changes based on observed performance in your specific context rather than theoretical considerations or general recommendations. Real-world performance often differs significantly from benchmark results or general reputation. + Make model changes based on observed performance in your specific context + rather than theoretical considerations or general recommendations. + Real-world performance often differs significantly from benchmark results or + general reputation. - Evaluate the complete cost of ownership including model costs, development time, maintenance overhead, and operational complexity. The cheapest model per token may not be the most cost-effective choice when considering all factors. + Evaluate the complete cost of ownership including model costs, development + time, maintenance overhead, and operational complexity. The cheapest model + per token may not be the most cost-effective choice when considering all + factors. -Focus on understanding your requirements first, then select models that best match those needs. The best LLM choice is the one that consistently delivers the results you need within your operational constraints. + Focus on understanding your requirements first, then select models that best + match those needs. The best LLM choice is the one that consistently delivers + the results you need within your operational constraints. ### Enterprise-Grade Model Validation -For teams serious about optimizing their LLM selection, the **CrewAI AOP platform** provides sophisticated testing capabilities that go far beyond basic CLI testing. The platform enables comprehensive model evaluation that helps you make data-driven decisions about your LLM strategy. +For teams serious about optimizing their LLM selection, the **CrewAI AMP platform** provides sophisticated testing capabilities that go far beyond basic CLI testing. The platform enables comprehensive model evaluation that helps you make data-driven decisions about your LLM strategy. ![Enterprise Testing Interface](/images/enterprise/enterprise-testing.png) @@ -562,7 +622,9 @@ For teams serious about optimizing their LLM selection, the **CrewAI AOP platfor Go to [app.crewai.com](https://app.crewai.com) to get started! -The Enterprise platform transforms model selection from guesswork into a data-driven process, enabling you to validate the principles in this guide with your actual use cases and requirements. + The Enterprise platform transforms model selection from guesswork into a + data-driven process, enabling you to validate the principles in this guide + with your actual use cases and requirements. ## Key Principles Summary @@ -572,21 +634,27 @@ The Enterprise platform transforms model selection from guesswork into a data-dr Choose models based on what the task actually requires, not theoretical capabilities or general reputation. - - Align model strengths with agent roles and responsibilities for optimal performance. - +{" "} + + Align model strengths with agent roles and responsibilities for optimal + performance. + - - Maintain coherent model selection strategy across related components and workflows. - +{" "} + + Maintain coherent model selection strategy across related components and + workflows. + - - Validate choices through real-world usage rather than benchmarks alone. - +{" "} + + Validate choices through real-world usage rather than benchmarks alone. + - - Start simple and optimize based on actual performance and needs. - +{" "} + + Start simple and optimize based on actual performance and needs. + Balance performance requirements with cost and complexity constraints. @@ -594,13 +662,20 @@ The Enterprise platform transforms model selection from guesswork into a data-dr -Remember: The best LLM choice is the one that consistently delivers the results you need within your operational constraints. Focus on understanding your requirements first, then select models that best match those needs. + Remember: The best LLM choice is the one that consistently delivers the + results you need within your operational constraints. Focus on understanding + your requirements first, then select models that best match those needs. ## Current Model Landscape (June 2025) -**Snapshot in Time**: The following model rankings represent current leaderboard standings as of June 2025, compiled from [LMSys Arena](https://arena.lmsys.org/), [Artificial Analysis](https://artificialanalysis.ai/), and other leading benchmarks. LLM performance, availability, and pricing change rapidly. Always conduct your own evaluations with your specific use cases and data. + **Snapshot in Time**: The following model rankings represent current + leaderboard standings as of June 2025, compiled from [LMSys + Arena](https://arena.lmsys.org/), [Artificial + Analysis](https://artificialanalysis.ai/), and other leading benchmarks. LLM + performance, availability, and pricing change rapidly. Always conduct your own + evaluations with your specific use cases and data. ### Leading Models by Category @@ -608,7 +683,10 @@ Remember: The best LLM choice is the one that consistently delivers the results The tables below show a representative sample of current top-performing models across different categories, with guidance on their suitability for CrewAI agents: -These tables/metrics showcase selected leading models in each category and are not exhaustive. Many excellent models exist beyond those listed here. The goal is to illustrate the types of capabilities to look for rather than provide a complete catalog. + These tables/metrics showcase selected leading models in each category and are + not exhaustive. Many excellent models exist beyond those listed here. The goal + is to illustrate the types of capabilities to look for rather than provide a + complete catalog. @@ -624,6 +702,7 @@ These tables/metrics showcase selected leading models in each category and are n | **Qwen3 235B (Reasoning)** | 62 | $2.63 | Moderate | Open-source alternative for reasoning tasks | These models excel at multi-step reasoning and are ideal for agents that need to develop strategies, coordinate other agents, or analyze complex information. + @@ -638,6 +717,7 @@ These tables/metrics showcase selected leading models in each category and are n | **Llama 3.1 405B** | Good | 81.1% | $3.50 | Function calling LLM for tool-heavy workflows | These models are optimized for code generation, debugging, and technical problem-solving, making them ideal for development-focused crews. + @@ -652,6 +732,7 @@ These tables/metrics showcase selected leading models in each category and are n | **Nova Micro** | High | 0.30s | $0.04 | Simple, fast task execution | These models prioritize speed and efficiency, perfect for agents handling routine operations or requiring quick responses. **Pro tip**: Pairing these models with fast inference providers like Groq can achieve even better performance, especially for open-source models like Llama. + @@ -666,6 +747,7 @@ These tables/metrics showcase selected leading models in each category and are n | **Qwen3 32B** | 44 | Good | $1.23 | Budget-friendly versatility | These models offer good performance across multiple dimensions, suitable for crews with diverse task requirements. + @@ -676,24 +758,28 @@ These tables/metrics showcase selected leading models in each category and are n **When performance is the priority**: Use top-tier models like **o3**, **Gemini 2.5 Pro**, or **Claude 4 Sonnet** for manager LLMs and critical agents. These models excel at complex reasoning and coordination but come with higher costs. **Strategy**: Implement a multi-model approach where premium models handle strategic thinking while efficient models handle routine operations. + **When budget is a primary constraint**: Focus on models like **DeepSeek R1**, **Llama 4 Scout**, or **Gemini 2.0 Flash**. These provide strong performance at significantly lower costs. **Strategy**: Use cost-effective models for most agents, reserving premium models only for the most critical decision-making roles. + **For specific domain expertise**: Choose models optimized for your primary use case. **Claude 4** series for coding, **Gemini 2.5 Pro** for research, **Llama 405B** for function calling. **Strategy**: Select models based on your crew's primary function, ensuring the core capability aligns with model strengths. + **For data-sensitive operations**: Consider open-source models like **Llama 4** series, **DeepSeek V3**, or **Qwen3** that can be deployed locally while maintaining competitive performance. **Strategy**: Deploy open-source models on private infrastructure, accepting potential performance trade-offs for data control. + @@ -706,7 +792,10 @@ These tables/metrics showcase selected leading models in each category and are n - **Open Source Viability**: The gap between open-source and proprietary models continues to narrow, with models like Llama 4 Maverick and DeepSeek V3 offering competitive performance at attractive price points. Fast inference providers particularly shine with open-source models, often delivering better speed-to-cost ratios than proprietary alternatives. -**Testing is Essential**: Leaderboard rankings provide general guidance, but your specific use case, prompting style, and evaluation criteria may produce different results. Always test candidate models with your actual tasks and data before making final decisions. + **Testing is Essential**: Leaderboard rankings provide general guidance, but + your specific use case, prompting style, and evaluation criteria may produce + different results. Always test candidate models with your actual tasks and + data before making final decisions. ### Practical Implementation Strategy @@ -716,13 +805,20 @@ These tables/metrics showcase selected leading models in each category and are n Begin with well-established models like **GPT-4.1**, **Claude 3.7 Sonnet**, or **Gemini 2.0 Flash** that offer good performance across multiple dimensions and have extensive real-world validation. - - Determine if your crew has specific requirements (coding, reasoning, speed) that would benefit from specialized models like **Claude 4 Sonnet** for development or **o3** for complex analysis. For speed-critical applications, consider fast inference providers like **Groq** alongside model selection. - +{" "} + + Determine if your crew has specific requirements (coding, reasoning, speed) + that would benefit from specialized models like **Claude 4 Sonnet** for + development or **o3** for complex analysis. For speed-critical applications, + consider fast inference providers like **Groq** alongside model selection. + - - Use different models for different agents based on their roles. High-capability models for managers and complex tasks, efficient models for routine operations. - +{" "} + + Use different models for different agents based on their roles. + High-capability models for managers and complex tasks, efficient models for + routine operations. + Track performance metrics relevant to your use case and be prepared to adjust model selections as new models are released or pricing changes. diff --git a/docs/en/mcp/dsl-integration.mdx b/docs/en/mcp/dsl-integration.mdx index c0ffbcb91..d630055e7 100644 --- a/docs/en/mcp/dsl-integration.mdx +++ b/docs/en/mcp/dsl-integration.mdx @@ -10,7 +10,9 @@ mode: "wide" CrewAI's MCP DSL (Domain Specific Language) integration provides the **simplest way** to connect your agents to MCP (Model Context Protocol) servers. Just add an `mcps` field to your agent and CrewAI handles all the complexity automatically. -This is the **recommended approach** for most MCP use cases. For advanced scenarios requiring manual connection management, see [MCPServerAdapter](/en/mcp/overview#advanced-mcpserveradapter). + This is the **recommended approach** for most MCP use cases. For advanced + scenarios requiring manual connection management, see + [MCPServerAdapter](/en/mcp/overview#advanced-mcpserveradapter). ## Basic Usage @@ -60,9 +62,9 @@ Use the `#` syntax to select specific tools from a server: "https://mcp.exa.ai/mcp?api_key=your_key#web_search_exa" ``` -### CrewAI AOP Marketplace +### CrewAI AMP Marketplace -Access tools from the CrewAI AOP marketplace: +Access tools from the CrewAI AMP marketplace: ```python # Full service with all tools @@ -97,7 +99,7 @@ multi_source_agent = Agent( "https://mcp.exa.ai/mcp?api_key=your_exa_key&profile=research", "https://weather.api.com/mcp#get_current_conditions", - # CrewAI AOP marketplace + # CrewAI AMP marketplace "crewai-amp:financial-insights", "crewai-amp:academic-research#pubmed_search", "crewai-amp:market-intelligence#competitor_analysis" @@ -319,6 +321,7 @@ agent = Agent( ### Common Issues **No tools discovered:** + ```python # Check your MCP server URL and authentication # Verify the server is running and accessible @@ -326,6 +329,7 @@ mcps=["https://mcp.example.com/mcp?api_key=valid_key"] ``` **Connection timeouts:** + ```python # Server may be slow or overloaded # CrewAI will log warnings and continue with other servers @@ -333,6 +337,7 @@ mcps=["https://mcp.example.com/mcp?api_key=valid_key"] ``` **Authentication failures:** + ```python # Verify API keys and credentials # Check server documentation for required parameters diff --git a/docs/en/mcp/overview.mdx b/docs/en/mcp/overview.mdx index 4171fa27a..63031982a 100644 --- a/docs/en/mcp/overview.mdx +++ b/docs/en/mcp/overview.mdx @@ -1,6 +1,6 @@ --- -title: 'MCP Servers as Tools in CrewAI' -description: 'Learn how to integrate MCP servers as tools in your CrewAI agents using the `crewai-tools` library.' +title: "MCP Servers as Tools in CrewAI" +description: "Learn how to integrate MCP servers as tools in your CrewAI agents using the `crewai-tools` library." icon: plug mode: "wide" --- @@ -17,7 +17,7 @@ Use the `mcps` field directly on agents for seamless MCP tool integration. The D #### String-Based References (Quick Setup) -Perfect for remote HTTPS servers and CrewAI AOP marketplace: +Perfect for remote HTTPS servers and CrewAI AMP marketplace: ```python from crewai import Agent @@ -29,7 +29,7 @@ agent = Agent( mcps=[ "https://mcp.exa.ai/mcp?api_key=your_key", # External MCP server "https://api.weather.com/mcp#get_forecast", # Specific tool from server - "crewai-amp:financial-data", # CrewAI AOP marketplace + "crewai-amp:financial-data", # CrewAI AMP marketplace "crewai-amp:research-tools#pubmed_search" # Specific AMP tool ] ) @@ -87,6 +87,7 @@ We currently support the following transport mechanisms: - **Streamable HTTPS**: for remote servers (flexible, potentially bi-directional communication over HTTPS, often utilizing SSE for server-to-client streams) ## Video Tutorial + Watch this video tutorial for a comprehensive guide on MCP integration with CrewAI: - - Get started with CrewAI AOP and deploy your crew in a production environment with just a few clicks. + + Get started with CrewAI AMP and deploy your crew in a production environment + with just a few clicks. - Join our open source community to discuss ideas, share your projects, and connect with other CrewAI developers. + Join our open source community to discuss ideas, share your projects, and + connect with other CrewAI developers. diff --git a/docs/enterprise-api.base.yaml b/docs/enterprise-api.base.yaml index 7b434ae20..03ae18aa3 100644 --- a/docs/enterprise-api.base.yaml +++ b/docs/enterprise-api.base.yaml @@ -1,12 +1,12 @@ openapi: 3.0.3 info: - title: CrewAI AOP API + title: CrewAI AMP API description: | - REST API for interacting with your deployed CrewAI crews on CrewAI AOP. + REST API for interacting with your deployed CrewAI crews on CrewAI AMP. ## Getting Started - 1. **Find your crew URL**: Get your unique crew URL from the CrewAI AOP dashboard + 1. **Find your crew URL**: Get your unique crew URL from the CrewAI AMP dashboard 2. **Copy examples**: Use the code examples from each endpoint page as templates 3. **Replace placeholders**: Update URLs and tokens with your actual values 4. **Test with your tools**: Use cURL, Postman, or your preferred API client @@ -18,7 +18,7 @@ info: - **Bearer Token**: Organization-level token for full crew operations - **User Bearer Token**: User-scoped token for individual access with limited permissions - You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AOP dashboard. + You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AMP dashboard. ## Reference Documentation @@ -43,7 +43,7 @@ info: url: https://crewai.com servers: - url: https://your-actual-crew-name.crewai.com - description: Replace with your actual deployed crew URL from the CrewAI AOP dashboard + description: Replace with your actual deployed crew URL from the CrewAI AMP dashboard - url: https://my-travel-crew.crewai.com description: Example travel planning crew (replace with your URL) - url: https://content-creation-crew.crewai.com @@ -420,7 +420,7 @@ components: description: | **📋 Reference Documentation** - *The tokens shown in examples are placeholders for reference only.* - Use your actual Bearer Token or User Bearer Token from the CrewAI AOP dashboard for real API calls. + Use your actual Bearer Token or User Bearer Token from the CrewAI AMP dashboard for real API calls. **Bearer Token**: Organization-level access for full crew operations **User Bearer Token**: User-scoped access with limited permissions diff --git a/docs/enterprise-api.en.yaml b/docs/enterprise-api.en.yaml index 7b434ae20..03ae18aa3 100644 --- a/docs/enterprise-api.en.yaml +++ b/docs/enterprise-api.en.yaml @@ -1,12 +1,12 @@ openapi: 3.0.3 info: - title: CrewAI AOP API + title: CrewAI AMP API description: | - REST API for interacting with your deployed CrewAI crews on CrewAI AOP. + REST API for interacting with your deployed CrewAI crews on CrewAI AMP. ## Getting Started - 1. **Find your crew URL**: Get your unique crew URL from the CrewAI AOP dashboard + 1. **Find your crew URL**: Get your unique crew URL from the CrewAI AMP dashboard 2. **Copy examples**: Use the code examples from each endpoint page as templates 3. **Replace placeholders**: Update URLs and tokens with your actual values 4. **Test with your tools**: Use cURL, Postman, or your preferred API client @@ -18,7 +18,7 @@ info: - **Bearer Token**: Organization-level token for full crew operations - **User Bearer Token**: User-scoped token for individual access with limited permissions - You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AOP dashboard. + You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AMP dashboard. ## Reference Documentation @@ -43,7 +43,7 @@ info: url: https://crewai.com servers: - url: https://your-actual-crew-name.crewai.com - description: Replace with your actual deployed crew URL from the CrewAI AOP dashboard + description: Replace with your actual deployed crew URL from the CrewAI AMP dashboard - url: https://my-travel-crew.crewai.com description: Example travel planning crew (replace with your URL) - url: https://content-creation-crew.crewai.com @@ -420,7 +420,7 @@ components: description: | **📋 Reference Documentation** - *The tokens shown in examples are placeholders for reference only.* - Use your actual Bearer Token or User Bearer Token from the CrewAI AOP dashboard for real API calls. + Use your actual Bearer Token or User Bearer Token from the CrewAI AMP dashboard for real API calls. **Bearer Token**: Organization-level access for full crew operations **User Bearer Token**: User-scoped access with limited permissions diff --git a/docs/enterprise-api.pt-BR.yaml b/docs/enterprise-api.pt-BR.yaml index f58d29da2..831ab81e5 100644 --- a/docs/enterprise-api.pt-BR.yaml +++ b/docs/enterprise-api.pt-BR.yaml @@ -1,12 +1,12 @@ openapi: 3.0.3 info: - title: CrewAI AOP API + title: CrewAI AMP API description: | - REST API para interagir com suas crews implantadas no CrewAI AOP. + REST API para interagir com suas crews implantadas no CrewAI AMP. ## Introdução - 1. **Encontre a URL da sua crew**: Obtenha sua URL única no painel do CrewAI AOP + 1. **Encontre a URL da sua crew**: Obtenha sua URL única no painel do CrewAI AMP 2. **Copie os exemplos**: Use os exemplos de cada endpoint como modelo 3. **Substitua os placeholders**: Atualize URLs e tokens com seus valores reais 4. **Teste com suas ferramentas**: Use cURL, Postman ou seu cliente preferido @@ -18,7 +18,7 @@ info: - **Bearer Token**: Token em nível de organização para operações completas - **User Bearer Token**: Token com escopo de usuário com permissões limitadas - Você encontra os tokens na aba Status da sua crew no painel do CrewAI AOP. + Você encontra os tokens na aba Status da sua crew no painel do CrewAI AMP. ## Documentação de Referência @@ -43,7 +43,7 @@ info: url: https://crewai.com servers: - url: https://your-actual-crew-name.crewai.com - description: Substitua pela URL real da sua crew no painel do CrewAI AOP + description: Substitua pela URL real da sua crew no painel do CrewAI AMP security: - BearerAuth: [] paths: @@ -291,7 +291,7 @@ components: scheme: bearer description: | **📋 Referência** - *Os tokens mostrados são apenas exemplos.* - Use seus tokens reais do painel do CrewAI AOP. + Use seus tokens reais do painel do CrewAI AMP. schemas: ExecutionRunning: diff --git a/docs/ko/api-reference/introduction.mdx b/docs/ko/api-reference/introduction.mdx index ea24b63bd..967e06264 100644 --- a/docs/ko/api-reference/introduction.mdx +++ b/docs/ko/api-reference/introduction.mdx @@ -1,6 +1,6 @@ --- title: "소개" -description: "CrewAI AOP REST API에 대한 완벽한 참고 자료" +description: "CrewAI AMP REST API에 대한 완벽한 참고 자료" icon: "code" mode: "wide" --- @@ -13,7 +13,7 @@ CrewAI 엔터프라이즈 API 참고 자료에 오신 것을 환영합니다. - CrewAI AOP 대시보드에서 자신의 crew 상세 페이지로 이동하여 Status 탭에서 Bearer Token을 복사하세요. + CrewAI AMP 대시보드에서 자신의 crew 상세 페이지로 이동하여 Status 탭에서 Bearer Token을 복사하세요. @@ -47,7 +47,7 @@ curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \ | **User Bearer Token** | 사용자 범위 접근 | 제한된 권한, 사용자별 작업에 적합 | - 두 토큰 유형 모두 CrewAI AOP 대시보드의 crew 상세 페이지 Status 탭에서 확인할 + 두 토큰 유형 모두 CrewAI AMP 대시보드의 crew 상세 페이지 Status 탭에서 확인할 수 있습니다. @@ -84,7 +84,7 @@ API는 표준 HTTP 상태 코드를 사용합니다: ## 인터랙티브 테스트 - **왜 "전송" 버튼이 없나요?** 각 CrewAI AOP 사용자는 고유한 crew URL을 + **왜 "전송" 버튼이 없나요?** 각 CrewAI AMP 사용자는 고유한 crew URL을 가지므로, 혼동을 피하기 위해 인터랙티브 플레이그라운드 대신 **참조 모드**를 사용합니다. 이를 통해 비작동 전송 버튼 없이 요청이 어떻게 생겼는지 정확히 보여줍니다. diff --git a/docs/ko/concepts/cli.mdx b/docs/ko/concepts/cli.mdx index 7fa5733d1..90e6d8789 100644 --- a/docs/ko/concepts/cli.mdx +++ b/docs/ko/concepts/cli.mdx @@ -5,7 +5,12 @@ icon: terminal mode: "wide" --- -릴리즈 0.140.0부터 CrewAI AOP는 로그인 제공자 마이그레이션 프로세스를 시작했습니다. 이에 따라 CLI를 통한 인증 흐름이 업데이트되었습니다. Google을 통해 로그인하거나 2025년 7월 3일 이후에 계정을 생성한 사용자는 이전 버전의 `crewai` 라이브러리로는 로그인할 수 없습니다. + + 릴리즈 0.140.0부터 CrewAI AOP는 로그인 제공자 마이그레이션 프로세스를 + 시작했습니다. 이에 따라 CLI를 통한 인증 흐름이 업데이트되었습니다. Google을 + 통해 로그인하거나 2025년 7월 3일 이후에 계정을 생성한 사용자는 이전 버전의 + `crewai` 라이브러리로는 로그인할 수 없습니다. + ## 개요 @@ -41,6 +46,7 @@ crewai create [OPTIONS] TYPE NAME - `NAME`: crew 또는 flow의 이름 예시: + ```shell Terminal crewai create crew my_new_crew crewai create flow my_new_flow @@ -57,6 +63,7 @@ crewai version [OPTIONS] - `--tools`: (선택 사항) 설치된 CrewAI tools의 버전을 표시합니다. 예시: + ```shell Terminal crewai version crewai version --tools @@ -74,6 +81,7 @@ crewai train [OPTIONS] - `-f, --filename TEXT`: 훈련에 사용할 커스텀 파일의 경로 (기본값: "trained_agents_data.pkl") 예시: + ```shell Terminal crewai train -n 10 -f my_training_data.pkl ``` @@ -89,6 +97,7 @@ crewai replay [OPTIONS] - `-t, --task_id TEXT`: 이 task ID에서부터 crew를 다시 재생하며, 이후의 모든 task를 포함합니다. 예시: + ```shell Terminal crewai replay -t task_123456 ``` @@ -118,6 +127,7 @@ crewai reset-memories [OPTIONS] - `-a, --all`: 모든 메모리 초기화 예시: + ```shell Terminal crewai reset-memories --long --short crewai reset-memories --all @@ -135,6 +145,7 @@ crewai test [OPTIONS] - `-m, --model TEXT`: Crew에서 테스트를 실행할 LLM 모델 (기본값: "gpt-4o-mini") 예시: + ```shell Terminal crewai test -n 5 -m gpt-3.5-turbo ``` @@ -148,12 +159,14 @@ crewai run ``` -버전 0.103.0부터 `crewai run` 명령은 표준 crew와 flow 모두를 실행하는 데 사용할 수 있습니다. flow의 경우 pyproject.toml에서 유형을 자동으로 감지하여 적절한 명령을 실행합니다. 이제 crew와 flow 모두를 실행하는 권장 방법입니다. + 버전 0.103.0부터 `crewai run` 명령은 표준 crew와 flow 모두를 실행하는 데 + 사용할 수 있습니다. flow의 경우 pyproject.toml에서 유형을 자동으로 감지하여 + 적절한 명령을 실행합니다. 이제 crew와 flow 모두를 실행하는 권장 방법입니다. -이 명령들은 CrewAI 프로젝트가 설정된 디렉터리에서 실행해야 합니다. -일부 명령은 프로젝트 구조 내에서 추가 구성 또는 설정이 필요할 수 있습니다. + 이 명령들은 CrewAI 프로젝트가 설정된 디렉터리에서 실행해야 합니다. 일부 명령은 + 프로젝트 구조 내에서 추가 구성 또는 설정이 필요할 수 있습니다. ### 9. Chat @@ -165,6 +178,7 @@ crewai run ```shell Terminal crewai chat ``` + 이 명령어들은 CrewAI 프로젝트의 루트 디렉터리에서 실행해야 합니다. @@ -182,28 +196,30 @@ def crew(self) -> Crew: chat_llm="gpt-4o", # LLM for chat orchestration ) ``` + ### 10. 배포 -crew 또는 flow를 [CrewAI AOP](https://app.crewai.com)에 배포하세요. +crew 또는 flow를 [CrewAI AMP](https://app.crewai.com)에 배포하세요. - **인증**: CrewAI AOP에 배포하려면 인증이 필요합니다. - 아래 명령어로 로그인하거나 계정을 생성할 수 있습니다: - ```shell Terminal - crewai login - ``` + 아래 명령어로 로그인하거나 계정을 생성할 수 있습니다: + + ```shell Terminal + crewai login + ``` - **배포 생성**: 인증이 완료되면, 로컬 프로젝트의 루트에서 crew 또는 flow에 대한 배포를 생성할 수 있습니다. - ```shell Terminal - crewai deploy create - ``` - - 로컬 프로젝트 구성을 읽어옵니다. - - 로컬에서 확인된 환경 변수(`OPENAI_API_KEY`, `SERPER_API_KEY` 등)를 확인하도록 안내합니다. 이 변수들은 Enterprise 플랫폼에 배포할 때 안전하게 저장됩니다. 실행 전에 중요한 키가 로컬(예: `.env` 파일)에 올바르게 구성되어 있는지 확인하세요. + ```shell Terminal + crewai deploy create + ``` + - 로컬 프로젝트 구성을 읽어옵니다. + - 로컬에서 확인된 환경 변수(`OPENAI_API_KEY`, `SERPER_API_KEY` 등)를 확인하도록 안내합니다. 이 변수들은 Enterprise 플랫폼에 배포할 때 안전하게 저장됩니다. 실행 전에 중요한 키가 로컬(예: `.env` 파일)에 올바르게 구성되어 있는지 확인하세요. ### 11. 조직 관리 -CrewAI AOP 조직을 관리합니다. +CrewAI AMP 조직을 관리합니다. ```shell Terminal crewai org [COMMAND] [OPTIONS] @@ -212,65 +228,79 @@ crewai org [COMMAND] [OPTIONS] #### 명령어: - `list`: 사용자가 속한 모든 조직을 나열합니다. + ```shell Terminal crewai org list ``` - `current`: 현재 활성화된 조직을 표시합니다. + ```shell Terminal crewai org current ``` - `switch`: 특정 조직으로 전환합니다. + ```shell Terminal crewai org switch ``` -이러한 조직 관리 명령어를 사용하려면 CrewAI AOP에 인증되어 있어야 합니다. + 이러한 조직 관리 명령어를 사용하려면 CrewAI AOP에 인증되어 있어야 합니다. - **배포 생성** (계속): - - 배포를 해당 원격 GitHub 저장소에 연결합니다 (일반적으로 자동으로 감지됩니다). + + - 배포를 해당 원격 GitHub 저장소에 연결합니다 (일반적으로 자동으로 감지됩니다). - **Crew 배포**: 인증이 완료되면 crew 또는 flow를 CrewAI AOP에 배포할 수 있습니다. - ```shell Terminal - crewai deploy push - ``` - - CrewAI AOP 플랫폼에서 배포 프로세스를 시작합니다. - - 성공적으로 시작되면, Deployment created successfully! 메시지와 함께 Deployment Name 및 고유한 Deployment ID(UUID)가 출력됩니다. + + ```shell Terminal + crewai deploy push + ``` + + - CrewAI AMP 플랫폼에서 배포 프로세스를 시작합니다. + - 성공적으로 시작되면, Deployment created successfully! 메시지와 함께 Deployment Name 및 고유한 Deployment ID(UUID)가 출력됩니다. - **배포 상태**: 배포 상태를 확인하려면 다음을 사용합니다: - ```shell Terminal - crewai deploy status - ``` - 이 명령은 가장 최근의 배포 시도에 대한 최신 배포 상태(예: `Building Images for Crew`, `Deploy Enqueued`, `Online`)를 가져옵니다. + + ```shell Terminal + crewai deploy status + ``` + + 이 명령은 가장 최근의 배포 시도에 대한 최신 배포 상태(예: `Building Images for Crew`, `Deploy Enqueued`, `Online`)를 가져옵니다. - **배포 로그**: 배포 로그를 확인하려면 다음을 사용합니다: - ```shell Terminal - crewai deploy logs - ``` - 이 명령은 배포 로그를 터미널로 스트리밍합니다. + + ```shell Terminal + crewai deploy logs + ``` + + 이 명령은 배포 로그를 터미널로 스트리밍합니다. - **배포 목록**: 모든 배포를 나열하려면 다음을 사용합니다: - ```shell Terminal - crewai deploy list - ``` - 이 명령은 모든 배포를 나열합니다. + + ```shell Terminal + crewai deploy list + ``` + + 이 명령은 모든 배포를 나열합니다. - **배포 삭제**: 배포를 삭제하려면 다음을 사용합니다: - ```shell Terminal - crewai deploy remove - ``` - 이 명령은 CrewAI AOP 플랫폼에서 배포를 삭제합니다. + + ```shell Terminal + crewai deploy remove + ``` + + 이 명령은 CrewAI AMP 플랫폼에서 배포를 삭제합니다. - **도움말 명령어**: CLI에 대한 도움말을 보려면 다음을 사용합니다: - ```shell Terminal - crewai deploy --help - ``` - 이 명령은 CrewAI Deploy CLI에 대한 도움말 메시지를 표시합니다. + ```shell Terminal + crewai deploy --help + ``` + 이 명령은 CrewAI Deploy CLI에 대한 도움말 메시지를 표시합니다. -CLI를 사용하여 [CrewAI AOP](http://app.crewai.com)에 crew를 배포하는 단계별 시연은 아래 비디오 튜토리얼을 참조하십시오. +CLI를 사용하여 [CrewAI AMP](http://app.crewai.com)에 crew를 배포하는 단계별 시연은 아래 비디오 튜토리얼을 참조하십시오. ## 텍스트 튜토리얼 + **Python 버전 요구 사항** - CrewAI는 `Python >=3.10 및 <3.14`가 필요합니다. 버전을 확인하는 방법은 다음과 같습니다: - ```bash - python3 --version - ``` +CrewAI는 `Python >=3.10 및 <3.14`가 필요합니다. 버전을 확인하는 방법은 다음과 같습니다: + +```bash +python3 --version +``` + +Python을 업데이트해야 하는 경우, [python.org/downloads](https://python.org/downloads)를 방문하세요. - Python을 업데이트해야 하는 경우, [python.org/downloads](https://python.org/downloads)를 방문하세요. CrewAI는 의존성 관리와 패키지 처리를 위해 `uv`를 사용합니다. 프로젝트 설정과 실행을 간소화하여 원활한 경험을 제공합니다. @@ -89,6 +93,7 @@ CrewAI는 의존성 관리와 패키지 처리를 위해 `uv`를 사용합니다 ``` 설치가 완료되었습니다! 이제 첫 번째 crew를 만들 준비가 되었습니다! 🎉 + # CrewAI 프로젝트 생성하기 @@ -122,6 +127,7 @@ CrewAI는 의존성 관리와 패키지 처리를 위해 `uv`를 사용합니다 ├── agents.yaml └── tasks.yaml ``` + @@ -138,6 +144,7 @@ CrewAI는 의존성 관리와 패키지 처리를 위해 `uv`를 사용합니다 - `agents.yaml` 및 `tasks.yaml`을 편집하여 crew의 동작을 정의하는 것부터 시작하세요. - API 키와 같은 민감한 정보는 `.env` 파일에 보관하세요. + @@ -161,13 +168,15 @@ CrewAI는 의존성 관리와 패키지 처리를 위해 `uv`를 사용합니다 팀과 조직을 위해, CrewAI는 설치 복잡성을 없애는 엔터프라이즈 배포 옵션을 제공합니다: -### CrewAI AOP (SaaS) +### CrewAI AMP (SaaS) + - 설치가 전혀 필요하지 않습니다 - [app.crewai.com](https://app.crewai.com)에서 무료로 가입하세요 - 자동 업데이트 및 유지 보수 - 관리형 인프라 및 확장성 지원 - 코딩 없이 Crew 생성 ### CrewAI Factory (자가 호스팅) + - 귀하의 인프라를 위한 컨테이너화된 배포 - 온프레미스 배포를 포함하여 모든 하이퍼스케일러 지원 - 기존 보안 시스템과의 통합 @@ -180,12 +189,9 @@ CrewAI는 의존성 관리와 패키지 처리를 위해 `uv`를 사용합니다 ## 다음 단계 - - 빠른 시작 가이드를 따라 CrewAI 에이전트를 처음 만들어보고 직접 경험해 보세요. + + 빠른 시작 가이드를 따라 CrewAI 에이전트를 처음 만들어보고 직접 경험해 + 보세요. -이 가이드는 LLM 환경이 빠르게 변화하고 있기 때문에 특정 모델 추천보다는 전략적 사고에 초점을 맞추고 있습니다. + 이 가이드는 LLM 환경이 빠르게 변화하고 있기 때문에 특정 모델 추천보다는 전략적 + 사고에 초점을 맞추고 있습니다. ## 빠른 결정 프레임워크 - 먼저, 작업이 실제로 무엇을 요구하는지 깊이 이해하세요. 필요한 인지 복잡성, 요구되는 추론의 깊이, 기대되는 출력 형식, 모델이 처리해야 할 맥락의 양을 고려합니다. 이러한 기본 분석이 이후의 모든 결정을 안내할 것입니다. + 먼저, 작업이 실제로 무엇을 요구하는지 깊이 이해하세요. 필요한 인지 복잡성, + 요구되는 추론의 깊이, 기대되는 출력 형식, 모델이 처리해야 할 맥락의 양을 + 고려합니다. 이러한 기본 분석이 이후의 모든 결정을 안내할 것입니다. - 요구 사항을 이해한 후, 이를 모델의 강점에 매핑하세요. 서로 다른 모델 계열은 작업 유형에 따라 특화되어 있습니다. 일부는 추론 및 분석에 최적화되어 있고, 일부는 창의성이나 콘텐츠 생성, 또 다른 일부는 속도와 효율성에 최적화되어 있습니다. + 요구 사항을 이해한 후, 이를 모델의 강점에 매핑하세요. 서로 다른 모델 계열은 + 작업 유형에 따라 특화되어 있습니다. 일부는 추론 및 분석에 최적화되어 있고, + 일부는 창의성이나 콘텐츠 생성, 또 다른 일부는 속도와 효율성에 최적화되어 + 있습니다. - 예산 제한, 지연 시간 요구사항, 데이터 프라이버시 필요성, 인프라 역량 등 실제 운영상의 제약 조건을 반영하세요. 이론적으로 가장 좋은 모델이 실제로는 최선의 선택이 아닐 수 있습니다. + 예산 제한, 지연 시간 요구사항, 데이터 프라이버시 필요성, 인프라 역량 등 실제 + 운영상의 제약 조건을 반영하세요. 이론적으로 가장 좋은 모델이 실제로는 최선의 + 선택이 아닐 수 있습니다. - 신뢰할 수 있고 잘 이해된 모델로 시작하여, 특정 사용 사례에서 실제 성능을 바탕으로 최적화하세요. 실제 결과는 이론적 벤치마크와 다를 수 있으므로, 경험적 테스트가 매우 중요합니다. + 신뢰할 수 있고 잘 이해된 모델로 시작하여, 특정 사용 사례에서 실제 성능을 + 바탕으로 최적화하세요. 실제 결과는 이론적 벤치마크와 다를 수 있으므로, + 경험적 테스트가 매우 중요합니다. @@ -43,6 +53,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 - **Complex Tasks**는 다단계 추론, 전략적 사고, 모호하거나 불완전한 정보를 처리하는 능력을 필요로 합니다. 여러 데이터 소스를 분석하거나, 포괄적 전략을 개발하거나, 더 작은 구성 요소로 분해해야 하는 문제 해결 작업 등이 이에 해당합니다. 모델은 여러 추론 단계를 거치는 동안 맥락을 유지해야 하며, 명시적으로 언급되지 않은 내용을 추론해야 할 때가 많습니다. - **Creative Tasks**는 새롭고, 흥미로우며, 맥락에 적합한 콘텐츠를 생성하는 데 중점을 둔 새로운 인지적 능력을 요구합니다. 여기에는 스토리텔링, 마케팅 카피 작성, 창의적 문제 해결이 포함됩니다. 모델은 뉘앙스, 톤, 대상 청중을 이해하고, 공식적이지 않고 진정성 있고 흥미로운 콘텐츠를 제작해야 합니다. + @@ -51,6 +62,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 - **Creative Content** 출력은 기술적 역량과 창의적 감각의 균형을 필요로 합니다. 모델은 대상 청중, 톤, 브랜드 보이스를 이해하고, 독자의 관심을 끌며 특정 커뮤니케이션 목표를 달성하는 콘텐츠를 제작할 수 있어야 합니다. 이 영역의 품질은 주관적인 경우가 많으며, 다양한 맥락과 목적에 맞게 글쓰기 스타일을 조정할 수 있는 모델이 필요합니다. - **Technical Content**는 구조화된 데이터와 창의적 콘텐츠의 중간에 위치하며, 정확성과 명확성을 모두 필요로 합니다. 문서화, 코드 생성, 기술 분석 등은 정밀하면서도 포괄적으로 작성되어야 하며, 대상이 되는 청중에게 효과적으로 전달되어야 합니다. 모델은 복잡한 기술 개념을 이해하고 이를 명확하게 설명할 수 있어야 합니다. + @@ -59,6 +71,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 - **Long Context** 요구 사항은 방대한 문서 작업, 장기간 대화, 복잡한 다중 파트 작업을 처리할 때 발생합니다. 모델은 수천 토큰에 걸쳐 일관성을 유지해야 하며, 앞선 정보를 정확히 참조할 수 있어야 합니다. 이는 문서 분석, 포괄적 연구, 정교한 대화 시스템에 매우 중요한 기능입니다. - **Very Long Context** 시나리오는 현재 가능한 한계를 뛰어넘는 경우로, 대규모 문서 처리, 광범위한 연구 종합, 복잡한 다중 세션 상호작용 등이 있습니다. 이러한 활용 사례는 확장된 컨텍스트 처리를 위해 특별히 설계된 모델이 필요하며, 종종 컨텍스트 길이와 처리 속도 간의 절충이 발생합니다. + @@ -73,6 +86,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 Reasoning 모델의 강점은 확장된 reasoning 체인에서 논리적 일관성을 유지하고, 복잡한 문제를 관리 가능한 구성 요소로 나눌 수 있다는 점에 있습니다. 전략적 계획, 복잡한 분석, 그리고 응답 속도보다 reasoning의 질이 더 중요한 상황에서 특히 가치가 있습니다. 하지만 reasoning 모델은 속도와 비용 면에서 트레이드오프가 따르는 경우가 많습니다. 또한 그들의 고도화된 reasoning 역량이 필요 없는 창의적인 작업이나 간단한 작업에는 덜 적합할 수 있습니다. 체계적이고 단계적인 분석이 요구되는 진정한 복잡성이 관련된 작업에서 이러한 모델을 고려하십시오. + @@ -81,6 +95,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 General purpose 모델의 주요 장점은 다양한 유형의 작업에서 예측 가능한 신뢰성과 일관성입니다. 조사, 분석, 콘텐츠 제작, 데이터 처리 등 대부분의 표준 비즈니스 작업을 충분히 처리할 수 있습니다. 이로 인해 다양한 워크플로우 전반에서 일관된 성능이 필요한 팀에 매우 적합한 선택이 됩니다. General purpose 모델은 특정 도메인에서 특화된 대안들이 보여주는 최고 성능에는 미치지 않을 수 있지만, 운영의 단순성과 모델 관리의 복잡성 감소라는 이점이 있습니다. 신규 프로젝트의 시작점으로 가장 좋은 선택인 경우가 많으며, 팀이 구체적인 필요를 이해하고 나서 특화 모델로 최적화할 수 있습니다. + @@ -89,6 +104,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 이러한 모델은 일상적인 운영, 간단한 데이터 처리, 함수 호출, 대용량 작업 등 인지적 요구가 비교적 단순한 시나리오에서 뛰어납니다. 많은 요청을 신속하게 처리해야 하거나 예산 제약 내에서 운영되어야 하는 애플리케이션에 특히 유용합니다. 효율적인 모델에서 가장 중요한 고려사항은 그들의 역량이 귀하의 작업 요구와 일치하는지 확인하는 것입니다. 많은 일상적 작업은 효과적으로 처리할 수 있지만, Nuanced한 이해, 복잡한 reasoning, 혹은 고도화된 콘텐츠 생성이 필요한 작업에는 어려움을 겪을 수 있습니다. 정교함보다 속도와 비용이 더 중요한 명확하고 일상적인 작업에 가장 적합합니다. + @@ -97,6 +113,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 Creative 모델의 강점은 다양한 대상에 맞춰 글쓰기 스타일을 조정하고, 일관된 목소리와 톤을 유지하며, 독자를 효과적으로 사로잡는 콘텐츠를 생성할 수 있다는 점입니다. 스토리텔링, 마케팅 카피, 브랜드 커뮤니케이션 등 창의성과 몰입이 주요 목적이 되는 콘텐츠 작업에서 더 우수한 성과를 보입니다. Creative 모델을 선택할 때는 단순한 텍스트 생성 능력뿐 아니라, 대상, 맥락, 목적에 대한 이해력도 함께 고려해야 합니다. 최상의 creative 모델은 특정 브랜드 목소리에 맞게 출력 내용을 조정하고, 다양한 대상 그룹을 타깃팅하며, 긴 콘텐츠에서도 일관성을 유지할 수 있습니다. + @@ -105,6 +122,7 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 Open source 모델의 주요 이점으로는 토큰당 비용의 제거, 특정 용도에 맞춘 파인튜닝 가능성, 완전한 데이터 프라이버시, 외부 API 제공자에 대한 의존성 해소가 있습니다. 특히 엄격한 데이터 프라이버시 요구사항, 예산 제약, 특정 맞춤화 필요가 있는 조직에 매우 유용합니다. 그러나 open source 모델은 효과적으로 배포 및 유지관리하기 위해 더 많은 기술 전문성이 필요합니다. 팀에서는 인프라 비용, 모델 관리 복잡성, 지속적인 모델 업데이트 및 최적화를 위한 지속적인 노력을 고려해야 합니다. 기술적 오버헤드를 감안하면 전체 소유 비용이 클라우드 기반 대안보다 높을 수 있습니다. + @@ -113,7 +131,8 @@ LLM을 선택할 때 가장 중요한 단계는 실제로 여러분의 작업이 ### a. 멀티-모델 접근 방식 -동일 crew 내에서 다양한 목적에 맞는 서로 다른 모델을 사용해 성능과 비용을 모두 최적화할 수 있습니다. + 동일 crew 내에서 다양한 목적에 맞는 서로 다른 모델을 사용해 성능과 비용을 모두 + 최적화할 수 있습니다. 가장 정교하게 구현된 CrewAI의 경우, 여러 개의 모델을 전략적으로 활용하여 각 agent의 역할과 요구 사항에 맞는 모델을 지정합니다. 이 접근 방식은 각 작업 유형에 가장 적합한 모델을 사용함으로써 성능과 비용을 모두 최적화할 수 있게 해줍니다. @@ -177,6 +196,7 @@ crew = Crew( 효과적인 Manager LLM은 올바른 위임 결정을 내리기 위한 강력한 추론 능력, 예측 가능한 조정을 보장하는 일관된 성능, 여러 에이전트의 상태를 동시에 추적하기 위한 탁월한 컨텍스트 관리가 필요합니다. 이 모델은 다양한 에이전트의 역량과 한계를 이해하고, 효율성과 품질을 최적화하기 위해 작업 할당을 최적화해야 합니다. Manager LLM은 모든 작업에 관여하기 때문에 비용 고려가 특히 중요합니다. 모델은 효과적인 조정을 위한 충분한 역량을 제공하면서도, 잦은 사용에도 비용 효율적이어야 합니다. 이는 종종 가장 정교한 모델의 높은 가격 없이도 충분한 추론 능력을 제공하는 모델을 찾는 것을 의미합니다. + @@ -185,6 +205,7 @@ crew = Crew( Function calling LLM에서 가장 중요한 특성은 창의성이나 정교한 추론력보다는 정확성과 신뢰성입니다. 모델은 자연어 요청에서 올바른 파라미터를 일관되게 추출하고, 도구 응답을 적절히 처리해야 합니다. 도구 사용은 여러 번의 왕복 작업이 수반될 수 있으므로 속도도 중요합니다. 많은 팀들은, 창의적이거나 추론에 특화된 모델보다는, 특화된 function calling 모델이나 도구 지원이 강력한 범용 모델이 이 역할에 더 적합하다는 것을 발견합니다. 핵심은 모델이 자연어 지침과 구조화된 도구 호출 간의 간극을 신뢰성 있게 연결할 수 있도록 하는 것입니다. + @@ -193,6 +214,7 @@ crew = Crew( 에이전트별 재정의를 고려해야 하는 경우는 에이전트의 역할이 다른 crew 구성원과 본질적으로 다른 역량을 요구할 때입니다. 예를 들어, 창의적 글쓰기에 특화된 에이전트는 콘텐츠 생성에 최적화된 모델이 도움이 될 수 있고, 데이터 분석 에이전트는 추론에 중점을 둔 모델로 더 나은 성과를 거둘 수 있습니다. 에이전트별 재정의를 적용할 때의 과제는 최적화와 운영 복잡도 간의 균형을 유지하는 것입니다. 모델이 하나 추가될 때마다 배포, 모니터링, 비용 관리의 복잡성이 늘어납니다. 따라서 팀은 성능 향상 효과가 추가 복잡성을 정당화할 수 있는 에이전트에만 재정의를 집중해야 합니다. + @@ -209,6 +231,7 @@ CrewAI 출력의 품질을 결정하는 데 있어 모델 선택보다 효과적 효과적인 작업 설명은 에이전트가 더 넓은 목적과 그들이 반드시 지켜야 할 제한사항을 이해할 수 있도록 관련 맥락 및 제약 조건을 포함합니다. 복잡한 작업을 체계적으로 실행할 수 있는 집중된 단계로 분할하여, 여러 측면이 뒤섞이고 접근하기 어려운 압도적인 목표로 제시하지 않습니다. 일반적인 실수로는 목표가 너무 모호하다거나, 필요한 맥락을 제공하지 않는다거나, 성공 기준이 불분명하다거나, 관련 없는 여러 작업을 하나의 설명으로 결합하는 경우가 있습니다. 목표는 단일의 명확한 목적에 집중하며, 에이전트가 성공할 수 있을 정도로 충분한 정보를 제공하는 것입니다. + @@ -217,6 +240,7 @@ CrewAI 출력의 품질을 결정하는 데 있어 모델 선택보다 효과적 최고의 산출물 가이드라인은 품질 지표에 대한 구체적인 예시를 제공하고, 완료 기준을 에이전트와 인간 평가자 모두가 작업의 성공적 완료 여부를 평가할 수 있을 만큼 명확하게 정의합니다. 이는 모호함을 줄이고 여러 작업 실행 간 일관된 결과를 보장하는 데 도움이 됩니다. 어떤 작업에나 적용할 수 있을 정도로 일반적인 산출물 설명, 에이전트가 구조를 추측해야 하는 형식 명세 누락, 평가가 어려운 불분명한 품질 기준, 에이전트가 기대치를 이해하도록 도와주는 예시 또는 템플릿 미제공 등은 피해야 합니다. + @@ -229,6 +253,7 @@ CrewAI 출력의 품질을 결정하는 데 있어 모델 선택보다 효과적 순차적 의존성을 효과적으로 구현하기 위해서는 context 파라미터를 사용하여 관련 작업을 연쇄시키고, 작업의 진행을 통해 점진적으로 복잡성을 구축하며, 각 작업이 다음 작업에 의미 있는 입력값이 될 수 있는 산출물을 생성하도록 해야 합니다. 목표는 의존된 작업 간의 논리적 흐름을 유지하면서 불필요한 병목을 피하는 것입니다. 순차적 의존성은 한 작업에서 다른 작업으로 명확한 논리적 진행이 있고, 한 작업의 산출물이 다음 작업의 품질이나 실행 가능성을 실제로 향상시킬 때 가장 효과적입니다. 그러나 적절히 관리되지 않을 경우 병목 현상이 발생할 수 있으니, 반드시 진정으로 필요한 의존성과 단순히 편의상 설정된 의존성을 구분해야 합니다. + @@ -237,6 +262,7 @@ CrewAI 출력의 품질을 결정하는 데 있어 모델 선택보다 효과적 성공적인 병렬 실행을 위해서는 실제로 독립적으로 수행이 가능한 작업을 식별하고, 관련되지만 분리된 작업 스트림을 효과적으로 그룹화하며, 병렬로 진행된 작업을 최종 결과물로 통합해야 할 때 결과 통합을 계획해야 합니다. 핵심은 병렬 작업이 전체 품질을 저하하는 충돌이나 중복을 만들지 않도록 하는 것입니다. 여러 개의 독립적인 연구 스트림이나 서로 의존하지 않는 다양한 분석, 동시에 개발이 가능한 콘텐츠 생성 작업이 있을 때 병렬 실행을 고려하십시오. 다만, 자원 할당에 주의하고, 병렬 실행이 모델의 가용 용량이나 예산을 초과하지 않도록 해야 합니다. + @@ -245,7 +271,8 @@ CrewAI 출력의 품질을 결정하는 데 있어 모델 선택보다 효과적 ### a. 역할 기반 LLM 선택 -일반적인 에이전트 역할은 올바른 LLM을 선택할 수 없게 만듭니다. 구체적인 역할은 목표에 맞춘 모델 최적화를 가능하게 합니다. + 일반적인 에이전트 역할은 올바른 LLM을 선택할 수 없게 만듭니다. 구체적인 역할은 + 목표에 맞춘 모델 최적화를 가능하게 합니다. 에이전트 역할의 구체성은 최적의 성능을 위해 어떤 LLM의 능력이 가장 중요한지를 직접적으로 결정합니다. 이는 에이전트의 책임에 정확히 맞는 모델 강점을 연결할 수 있는 전략적 기회를 만듭니다. @@ -253,6 +280,7 @@ CrewAI 출력의 품질을 결정하는 데 있어 모델 선택보다 효과적 **일반 역할 vs. 구체적 역할이 LLM 선택에 미치는 영향:** 역할을 정의할 때 에이전트가 다룰 작업에 가장 가치 있는 특정 도메인 지식, 작업 방식, 의사결정 프레임워크를 고려하세요. 역할 정의가 더 구체적이고 상황에 맞을수록 모델이 그 역할을 효과적으로 구현할 수 있습니다. + ```python # ✅ 특정 역할 - 명확한 LLM 요구 specific_agent = Agent( @@ -273,7 +301,9 @@ specific_agent = Agent( ### b. 모델 컨텍스트 증폭기로서의 백스토리 -전략적으로 구성된 백스토리는 도메인 특화 컨텍스트를 제공하여 일반적인 프롬프트로는 달성할 수 없는 수준으로 선택한 LLM의 효율성을 획기적으로 높여줍니다. + 전략적으로 구성된 백스토리는 도메인 특화 컨텍스트를 제공하여 일반적인 + 프롬프트로는 달성할 수 없는 수준으로 선택한 LLM의 효율성을 획기적으로 + 높여줍니다. 잘 설계된 백스토리는 LLM을 단순한 범용 모델에서 전문적인 전문가로 탈바꿈시켜 줍니다. 이는 비용 최적화 관점에서 특히 중요합니다. 효율적인 모델이라도 컨텍스트가 잘 구축되면, 적절한 컨텍스트 없이 고가의 모델보다 더 뛰어난 성능을 발휘할 수 있습니다. @@ -300,6 +330,7 @@ domain_expert = Agent( ``` **LLM 성능을 높여주는 백스토리 요소:** + - **도메인 경험**: "10년 이상의 엔터프라이즈 SaaS 영업 경력" - **특정 전문성**: "시리즈 B+ 라운드의 기술 실사 전문" - **업무 스타일**: "명확한 문서화와 데이터 기반 의사결정을 선호" @@ -332,6 +363,7 @@ tech_writer = Agent( ``` **정렬 체크리스트:** + - ✅ **역할 특이성**: 명확한 도메인과 책임 - ✅ **LLM 적합도**: 모델의 강점이 역할 요구사항과 일치 - ✅ **백스토리 깊이**: LLM이 활용할 수 있는 도메인 맥락 제공 @@ -353,6 +385,7 @@ tech_writer = Agent( - 도구에 크게 의존하는 agent가 있습니까? **Action**: 현재 agent 역할을 문서화하고 최적화 기회를 식별하세요. + @@ -369,6 +402,7 @@ tech_writer = Agent( ``` **Action**: 개별 agent 최적화 전에 crew의 기본 LLM을 설정하세요. + @@ -390,16 +424,18 @@ tech_writer = Agent( ``` **Action**: 복잡도의 80%를 처리하는 agent 20%를 업그레이드하세요. + **agent를 프로덕션에 배포한 후:** - - [CrewAI AOP platform](https://app.crewai.com)을 활용하여 모델 선택을 A/B 테스트하세요 + - [CrewAI AMP platform](https://app.crewai.com)을 활용하여 모델 선택을 A/B 테스트하세요 - 실제 입력으로 여러 번 반복 테스트하여 일관성과 성능을 측정하세요 - 최적화된 셋업 전반의 비용과 성능을 비교하세요 - 팀과 결과를 공유하여 협업 의사결정을 지원하세요 **Action**: 테스트 플랫폼을 활용해 추측이 아닌 데이터 기반 검증을 실행하세요. + @@ -412,6 +448,7 @@ tech_writer = Agent( 예를 들어, 비즈니스 전략 개발, 여러 출처에서 인사이트를 도출해야 하는 복잡한 데이터 분석, 각 단계가 이전 분석을 기반으로 해야 하는 다단계 문제 해결, 다양한 변수 및 이들의 상호작용을 고려해야 하는 전략적 계획 수립 업무에 reasoning 모델을 고려해 보세요. 그러나 reasoning 모델은 일반적으로 더 높은 비용과 느린 응답 시간을 수반하므로, 복잡한 사고가 필요한 작업에서 실질적인 가치를 제공할 때에만 사용하는 것이 좋으며, 복잡한 reasoning이 필요하지 않은 단순한 작업에는 권장되지 않습니다. + @@ -420,6 +457,7 @@ tech_writer = Agent( creative 모델은 블로그 포스트 작성 및 기사 생성, 독자를 끌어들이고 설득해야 하는 마케팅 카피, 창의적인 스토리텔링 및 내러티브 개발, 목소리와 톤이 중요한 브랜드 커뮤니케이션 등에 적합합니다. 이 모델은 일반 목적 모델보다 뉘앙스와 맥락을 더 잘 이해할 수 있습니다. creative 모델은 정밀성과 사실적 정확성이 스타일이나 참여도보다 더 중요한 기술적 또는 분석적 작업에는 덜 적합할 수 있습니다. 결과물의 창의적·의사소통적 측면이 성공의 주요 요인일 때 사용하는 것이 가장 좋습니다. + @@ -428,6 +466,7 @@ tech_writer = Agent( efficient 모델은 데이터 처리 및 변환 작업, 단순한 서식 지정 및 정리 작업, 정밀성이 중요하고 복잡함보다는 정확성이 필요한 함수 호출 및 도구 사용, 1회 작업당 비용이 중대한 고볼륨 작업에 적합합니다. efficient 모델에서는 해당 모델의 역량이 작업 요구 사항과 일치하는지 확인하는 것이 핵심입니다. 다양한 반복 작업을 효과적으로 처리할 수 있지만, 뉘앙스 이해, 복잡한 reasoning, 고도화된 콘텐츠 생성이 필요한 작업에서는 한계가 있을 수 있습니다. + @@ -436,6 +475,7 @@ tech_writer = Agent( 예를 들어, 데이터 프라이버시가 최우선인 사내 도구, 외부 API를 사용할 수 없는 프라이버시 민감형 애플리케이션, 토큰 단위 가격이 부담스러운 비용 최적화 배포, 모델 수정 또는 파인튜닝이 필요한 상황에서 open source 모델을 고려해 보세요. 단, open source 모델은 효과적으로 배포하고 유지하기 위해 더 많은 기술 전문성이 요구됩니다. 인프라, 기술적 오버헤드, 지속적인 유지보수를 포함한 전체 소유 비용을 종합적으로 평가해야 합니다. + @@ -455,6 +495,7 @@ tech_writer = Agent( # 처리 agent는 효율적인 모델 사용 processor = Agent(role="Data Processor", llm=LLM(model="gpt-4o-mini")) ``` + @@ -474,6 +515,7 @@ tech_writer = Agent( # agent는 특별히 지정하지 않으면 crew LLM을 상속받음 agent1 = Agent(llm=LLM(model="claude-3-5-sonnet")) # 특정 요구에 따라 오버라이드 ``` + @@ -492,6 +534,7 @@ tech_writer = Agent( llm=LLM(model="claude-3-5-sonnet") # 도구 사용에 강점 ) ``` + @@ -507,6 +550,7 @@ tech_writer = Agent( # 성능을 테스트하고, 필요에 따라 특정 agent만 최적화 # Enterprise 플랫폼 테스트를 통해 개선 사항 검증 ``` + @@ -515,6 +559,7 @@ tech_writer = Agent( **실제 예시**: 여러 차례 반복되는 업무나 agent 간 활발한 소통이 필요한 crew에 대화 내역을 오래 유지해야 하는데, 짧은 컨텍스트 모델을 사용한 경우. **CrewAI 솔루션**: crew의 소통 패턴에 맞춰 컨텍스트 처리 능력을 갖춘 모델을 선택. + @@ -522,26 +567,36 @@ tech_writer = Agent( - 신뢰할 수 있고, 잘 알려져 있으며, 널리 지원되는 범용 모델로 시작하세요. 이것은 최적화된 특수한 필요에 집중하기 전에 귀하의 특정 요구사항과 성능 기대치를 이해할 수 있는 안정적인 기초를 제공합니다. + 신뢰할 수 있고, 잘 알려져 있으며, 널리 지원되는 범용 모델로 시작하세요. + 이것은 최적화된 특수한 필요에 집중하기 전에 귀하의 특정 요구사항과 성능 + 기대치를 이해할 수 있는 안정적인 기초를 제공합니다. - 일반적인 벤치마크에만 의존하지 말고, 귀하의 특정 사용 사례와 비즈니스 요구에 부합하는 지표를 개발하세요. 이론적 성능 지표가 아니라 성공에 직접적으로 영향을 미치는 결과 측정에 집중하세요. + 일반적인 벤치마크에만 의존하지 말고, 귀하의 특정 사용 사례와 비즈니스 요구에 + 부합하는 지표를 개발하세요. 이론적 성능 지표가 아니라 성공에 직접적으로 + 영향을 미치는 결과 측정에 집중하세요. - 이론적 고려사항이나 일반적인 권장사항이 아니라, 귀하의 특정 상황에서 관찰된 성능에 따라 모델을 변경하세요. 실제 성능은 벤치마크 결과나 일반적인 평판과는 크게 다를 수 있습니다. + 이론적 고려사항이나 일반적인 권장사항이 아니라, 귀하의 특정 상황에서 관찰된 + 성능에 따라 모델을 변경하세요. 실제 성능은 벤치마크 결과나 일반적인 평판과는 + 크게 다를 수 있습니다. - 모델 비용, 개발 시간, 유지 보수 오버헤드, 운영 복잡성 등 소유에 드는 전체 비용을 평가하세요. 토큰당 가장 저렴한 모델이 모든 요소를 고려했을 때 반드시 가장 비용 효율적이지는 않을 수 있습니다. + 모델 비용, 개발 시간, 유지 보수 오버헤드, 운영 복잡성 등 소유에 드는 전체 + 비용을 평가하세요. 토큰당 가장 저렴한 모델이 모든 요소를 고려했을 때 반드시 + 가장 비용 효율적이지는 않을 수 있습니다. -먼저 귀하의 요구사항을 이해하는 데 집중한 후, 그 요구와 가장 잘 맞는 모델을 선택하세요. 최상의 LLM 선택은 운영상의 제약 조건 내에서 꾸준히 원하는 결과를 제공하는 것입니다. + 먼저 귀하의 요구사항을 이해하는 데 집중한 후, 그 요구와 가장 잘 맞는 모델을 + 선택하세요. 최상의 LLM 선택은 운영상의 제약 조건 내에서 꾸준히 원하는 결과를 + 제공하는 것입니다. ### 엔터프라이즈급 모델 검증 -LLM 선택을 최적화하고자 하는 팀을 위해 **CrewAI AOP 플랫폼**은 기본적인 CLI 테스트를 훨씬 능가하는 정교한 테스트 기능을 제공합니다. 이 플랫폼은 데이터 기반의 LLM 전략 의사결정을 지원하는 종합적인 모델 평가를 가능하게 합니다. +LLM 선택을 최적화하고자 하는 팀을 위해 **CrewAI AMP 플랫폼**은 기본적인 CLI 테스트를 훨씬 능가하는 정교한 테스트 기능을 제공합니다. 이 플랫폼은 데이터 기반의 LLM 전략 의사결정을 지원하는 종합적인 모델 평가를 가능하게 합니다. ![엔터프라이즈 테스트 인터페이스](/images/enterprise/enterprise-testing.png) @@ -562,7 +617,9 @@ LLM 선택을 최적화하고자 하는 팀을 위해 **CrewAI AOP 플랫폼** 지금 [app.crewai.com](https://app.crewai.com)에서 시작하세요! -Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 기반 프로세스로 혁신하여, 본 가이드의 원칙을 실제 사용 사례와 요구 사항에 맞게 검증할 수 있도록 해줍니다. + Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 기반 프로세스로 + 혁신하여, 본 가이드의 원칙을 실제 사용 사례와 요구 사항에 맞게 검증할 수 + 있도록 해줍니다. ## 주요 원칙 요약 @@ -572,21 +629,25 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 이론적 능력이나 일반적인 평판이 아니라, 작업에 실제로 필요한 것에 따라 모델을 선택하세요. - - 최적의 성능을 위해 모델의 강점을 agent의 역할 및 책임과 일치시키세요. - +{" "} + + 최적의 성능을 위해 모델의 강점을 agent의 역할 및 책임과 일치시키세요. + - - 관련 구성 요소와 워크플로 전반에 걸쳐 일관된 모델 선택 전략을 유지하세요. - +{" "} + + 관련 구성 요소와 워크플로 전반에 걸쳐 일관된 모델 선택 전략을 유지하세요. + - - 벤치마크에만 의존하지 말고 실제 사용을 통해 선택을 검증하세요. - +{" "} + + 벤치마크에만 의존하지 말고 실제 사용을 통해 선택을 검증하세요. + - - 단순하게 시작하고 실제 성능과 필요에 따라 최적화하세요. - +{" "} + + 단순하게 시작하고 실제 성능과 필요에 따라 최적화하세요. + 성능 요구사항과 비용 및 복잡성 제약을 균형 있게 맞추세요. @@ -594,13 +655,19 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 -기억하세요: 최고의 LLM 선택이란 운영상의 제약 내에서 일관되게 필요한 결과를 제공하는 모델입니다. 먼저 요구사항을 정확히 이해하는 데 집중한 후, 그에 가장 잘 맞는 모델을 선택하세요. + 기억하세요: 최고의 LLM 선택이란 운영상의 제약 내에서 일관되게 필요한 결과를 + 제공하는 모델입니다. 먼저 요구사항을 정확히 이해하는 데 집중한 후, 그에 가장 + 잘 맞는 모델을 선택하세요. ## 현재 모델 현황 (2025년 6월) -**특정 시점의 스냅샷**: 아래 모델 순위는 2025년 6월 기준으로, [LMSys Arena](https://arena.lmsys.org/), [Artificial Analysis](https://artificialanalysis.ai/) 및 기타 주요 벤치마크에서 집계된 최신 리더보드 결과입니다. LLM의 성능, 가용성, 가격은 빠르게 변동됩니다. 항상 귀하의 특정 사용 사례와 데이터로 직접 평가를 진행하시기 바랍니다. + **특정 시점의 스냅샷**: 아래 모델 순위는 2025년 6월 기준으로, [LMSys + Arena](https://arena.lmsys.org/), [Artificial + Analysis](https://artificialanalysis.ai/) 및 기타 주요 벤치마크에서 집계된 + 최신 리더보드 결과입니다. LLM의 성능, 가용성, 가격은 빠르게 변동됩니다. 항상 + 귀하의 특정 사용 사례와 데이터로 직접 평가를 진행하시기 바랍니다. ### 카테고리별 주요 모델 @@ -608,7 +675,10 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 아래 표는 다양한 카테고리에서 현재 최고의 성능을 보이는 대표적인 모델들을 보여주며, CrewAI 에이전트에 적합한 모델 선택에 대한 가이드를 제공합니다: -이 표와 지표는 각 카테고리에서 선별된 주요 모델을 보여주기 위한 것으로, 전체를 포괄하지 않습니다. 여기 소개되지 않은 훌륭한 모델들도 많이 존재합니다. 이 표의 목적은 완전한 목록을 제공하는 것이 아니라, 어떤 능력을 갖춘 모델을 찾아야 하는지 예시를 제시하는 것입니다. + 이 표와 지표는 각 카테고리에서 선별된 주요 모델을 보여주기 위한 것으로, 전체를 + 포괄하지 않습니다. 여기 소개되지 않은 훌륭한 모델들도 많이 존재합니다. 이 표의 + 목적은 완전한 목록을 제공하는 것이 아니라, 어떤 능력을 갖춘 모델을 찾아야 + 하는지 예시를 제시하는 것입니다. @@ -624,6 +694,7 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 | **Qwen3 235B (Reasoning)** | 62 | $2.63 | 보통 | reasoning 작업을 위한 오픈소스 대안 | 이 모델들은 다단계 reasoning에 뛰어나며, 전략을 개발하거나 다른 에이전트를 조정하거나 복잡한 정보를 분석해야 하는 에이전트에 이상적입니다. + @@ -638,6 +709,7 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 | **Llama 3.1 405B** | 좋음 | 81.1% | $3.50 | 도구 사용이 많은 워크플로우를 위한 function calling LLM | 이 모델들은 코드 생성, 디버깅, 기술 문제 해결에 최적화되어 있어, 개발 중심 팀에 적합합니다. + @@ -652,6 +724,7 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 | **Nova Micro** | 높음 | 0.30s | $0.04 | 단순·빠른 작업 처리 | 이 모델들은 속도와 효율을 우선시하며, 일상적 운영 또는 신속한 응답이 필요한 에이전트에게 최적입니다. **팁**: 이러한 모델을 Groq와 같은 빠른 추론 제공자와 함께 사용하면 더욱 우수한 성능을 낼 수 있습니다. 특히 Llama와 같은 오픈소스 모델에 적합합니다. + @@ -666,6 +739,7 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 | **Qwen3 32B** | 44 | 좋음 | $1.23 | 예산 친화적 다재다능성 | 이 모델들은 다양한 측면에서 우수한 성능을 제공하며, 여러 작업이 혼합된 팀에 적합합니다. + @@ -676,24 +750,28 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 **퍼포먼스가 우선 순위일 때**: 매니저 LLM 또는 중요한 에이전트 역할에는 **o3**, **Gemini 2.5 Pro**, **Claude 4 Sonnet**과 같은 최상위 모델을 사용하세요. 이 모델들은 복잡한 reasoning 및 coordination에 탁월하지만 비용이 더 높습니다. **전략**: 프리미엄 모델이 전략적 사고를 담당하고, 효율적인 모델이 일상적 operation을 처리하는 멀티 모델 접근법을 구현하세요. + **예산이 주요 제약일 때**: **DeepSeek R1**, **Llama 4 Scout**, **Gemini 2.0 Flash**와 같은 모델에 집중하세요. 이 모델들은 훨씬 낮은 비용으로 강력한 퍼포먼스를 제공합니다. **전략**: 대부분의 에이전트에는 비용 효율이 높은 모델을 사용하고, 가장 중요한 decision-making 역할에만 프리미엄 모델을 남겨두세요. + **특정 도메인 전문성이 필요할 때**: 주된 사용 사례에 최적화된 모델을 선택하세요. 코딩에는 **Claude 4** 시리즈, 리서치에는 **Gemini 2.5 Pro**, function calling에는 **Llama 405B**를 사용하세요. **전략**: crew의 주요 기능에 따라 모델을 선택해, 핵심 역량이 모델의 강점과 일치하도록 하세요. + **데이터 민감한 operation의 경우**: 로컬에서 배포 가능하면서 경쟁력 있는 퍼포먼스를 유지하는 오픈 소스 모델인 **Llama 4** 시리즈, **DeepSeek V3**, **Qwen3** 등을 고려하세요. **전략**: 사설 인프라에 오픈 소스 모델을 배포하여, 데이터 제어를 위해 필요한 퍼포먼스 손실을 감수하세요. + @@ -706,7 +784,10 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 - **오픈 소스의 실효성**: 오픈 소스와 독점 모델 간의 격차가 계속 좁혀지고 있으며, Llama 4 Maverick 및 DeepSeek V3와 같은 모델이 매력적인 가격대에서 경쟁력 있는 성능을 제공합니다. 특히 빠른 추론을 제공하는 업체들은 오픈 소스 모델과 함께 탁월한 속도-비용 비율을 제공하는 경우가 많아 독점 모델보다 우위에 서기도 합니다. -**테스트는 필수입니다**: 리더보드 순위는 일반적인 가이드라인을 제공하지만, 귀하의 특정 사용 사례, 프롬프트 스타일, 평가 기준에 따라 결과가 달라질 수 있습니다. 최종 결정을 내리기 전에 반드시 실제 작업과 데이터로 후보 모델을 테스트해 보세요. + **테스트는 필수입니다**: 리더보드 순위는 일반적인 가이드라인을 제공하지만, + 귀하의 특정 사용 사례, 프롬프트 스타일, 평가 기준에 따라 결과가 달라질 수 + 있습니다. 최종 결정을 내리기 전에 반드시 실제 작업과 데이터로 후보 모델을 + 테스트해 보세요. ### 실질적인 구현 전략 @@ -716,13 +797,19 @@ Enterprise 플랫폼은 모델 선택을 단순한 추측이 아닌 데이터 여러 차원에서 우수한 성능을 제공하며 실제 환경에서 광범위하게 검증된 **GPT-4.1**, **Claude 3.7 Sonnet**, **Gemini 2.0 Flash**와 같은 잘 알려진 모델부터 시작하십시오. - - crew에 코드 작성, reasoning, 속도 등 특정 요구가 있는지 확인하고, 이러한 요구에 부합하는 **Claude 4 Sonnet**(개발용) 또는 **o3**(복잡한 분석용)과 같은 특화 모델을 고려하십시오. 속도가 중요한 애플리케이션의 경우, 모델 선택과 더불어 **Groq**와 같은 빠른 추론 제공자를 고려할 수 있습니다. - +{" "} + + crew에 코드 작성, reasoning, 속도 등 특정 요구가 있는지 확인하고, 이러한 + 요구에 부합하는 **Claude 4 Sonnet**(개발용) 또는 **o3**(복잡한 분석용)과 같은 + 특화 모델을 고려하십시오. 속도가 중요한 애플리케이션의 경우, 모델 선택과 + 더불어 **Groq**와 같은 빠른 추론 제공자를 고려할 수 있습니다. + - - 각 에이전트의 역할에 따라 다양한 모델을 사용하세요. 관리자와 복잡한 작업에는 고성능 모델을, 일상적 운영에는 효율적인 모델을 적용합니다. - +{" "} + + 각 에이전트의 역할에 따라 다양한 모델을 사용하세요. 관리자와 복잡한 작업에는 + 고성능 모델을, 일상적 운영에는 효율적인 모델을 적용합니다. + 사용 사례와 관련된 성능 지표를 추적하고, 새로운 모델이 출시되거나 가격이 변동될 때 모델 선택을 조정할 준비를 하십시오. diff --git a/docs/ko/mcp/dsl-integration.mdx b/docs/ko/mcp/dsl-integration.mdx index d7da0d788..56bb63911 100644 --- a/docs/ko/mcp/dsl-integration.mdx +++ b/docs/ko/mcp/dsl-integration.mdx @@ -10,7 +10,9 @@ mode: "wide" CrewAI의 MCP DSL(Domain Specific Language) 통합은 에이전트를 MCP(Model Context Protocol) 서버에 연결하는 **가장 간단한 방법**을 제공합니다. 에이전트에 `mcps` 필드만 추가하면 CrewAI가 모든 복잡성을 자동으로 처리합니다. -이는 대부분의 MCP 사용 사례에 **권장되는 접근 방식**입니다. 수동 연결 관리가 필요한 고급 시나리오의 경우 [MCPServerAdapter](/ko/mcp/overview#advanced-mcpserveradapter)를 참조하세요. + 이는 대부분의 MCP 사용 사례에 **권장되는 접근 방식**입니다. 수동 연결 관리가 + 필요한 고급 시나리오의 경우 + [MCPServerAdapter](/ko/mcp/overview#advanced-mcpserveradapter)를 참조하세요. ## 기본 사용법 @@ -60,9 +62,9 @@ agent = Agent( "https://mcp.exa.ai/mcp?api_key=your_key#web_search_exa" ``` -### CrewAI AOP 마켓플레이스 +### CrewAI AMP 마켓플레이스 -CrewAI AOP 마켓플레이스의 도구에 액세스하세요: +CrewAI AMP 마켓플레이스의 도구에 액세스하세요: ```python # 모든 도구가 포함된 전체 서비스 @@ -97,7 +99,7 @@ multi_source_agent = Agent( "https://mcp.exa.ai/mcp?api_key=your_exa_key&profile=research", "https://weather.api.com/mcp#get_current_conditions", - # CrewAI AOP 마켓플레이스 + # CrewAI AMP 마켓플레이스 "crewai-amp:financial-insights", "crewai-amp:academic-research#pubmed_search", "crewai-amp:market-intelligence#competitor_analysis" diff --git a/docs/ko/mcp/overview.mdx b/docs/ko/mcp/overview.mdx index c3b290840..23b58ded9 100644 --- a/docs/ko/mcp/overview.mdx +++ b/docs/ko/mcp/overview.mdx @@ -1,6 +1,6 @@ --- -title: 'CrewAI에서 MCP 서버를 도구로 활용하기' -description: '`crewai-tools` 라이브러리를 사용하여 MCP 서버를 CrewAI agent에 도구로 통합하는 방법을 알아봅니다.' +title: "CrewAI에서 MCP 서버를 도구로 활용하기" +description: "`crewai-tools` 라이브러리를 사용하여 MCP 서버를 CrewAI agent에 도구로 통합하는 방법을 알아봅니다." icon: plug mode: "wide" --- @@ -25,7 +25,7 @@ agent = Agent( mcps=[ "https://mcp.exa.ai/mcp?api_key=your_key", # 외부 MCP 서버 "https://api.weather.com/mcp#get_forecast", # 서버의 특정 도구 - "crewai-amp:financial-data", # CrewAI AOP 마켓플레이스 + "crewai-amp:financial-data", # CrewAI AMP 마켓플레이스 "crewai-amp:research-tools#pubmed_search" # 특정 AMP 도구 ] ) @@ -43,6 +43,7 @@ agent = Agent( - **Streamable HTTP**: 원격 서버용 (유연하며 잠재적으로 양방향 통신이 가능, 주로 SSE를 활용한 서버-클라이언트 스트림 제공, HTTP 기반) ## 비디오 튜토리얼 + CrewAI와 MCP 통합에 대한 종합적인 안내를 위해 이 비디오 튜토리얼을 시청하세요: - - CrewAI AOP로 시작하여 몇 번의 클릭만으로 production 환경에 crew를 배포하세요. + + CrewAI AOP로 시작하여 몇 번의 클릭만으로 production 환경에 crew를 + 배포하세요. - 오픈 소스 커뮤니티에 참여하여 아이디어를 나누고, 프로젝트를 공유하며, 다른 CrewAI 개발자들과 소통하세요. + 오픈 소스 커뮤니티에 참여하여 아이디어를 나누고, 프로젝트를 공유하며, 다른 + CrewAI 개발자들과 소통하세요. diff --git a/docs/pt-BR/api-reference/introduction.mdx b/docs/pt-BR/api-reference/introduction.mdx index 2ddbe9720..e071e3b1b 100644 --- a/docs/pt-BR/api-reference/introduction.mdx +++ b/docs/pt-BR/api-reference/introduction.mdx @@ -1,19 +1,19 @@ --- title: "Introdução" -description: "Referência completa para a API REST do CrewAI AOP" +description: "Referência completa para a API REST do CrewAI AMP" icon: "code" mode: "wide" --- -# CrewAI AOP API +# CrewAI AMP API -Bem-vindo à referência da API do CrewAI AOP. Esta API permite que você interaja programaticamente com seus crews implantados, possibilitando a integração com seus aplicativos, fluxos de trabalho e serviços. +Bem-vindo à referência da API do CrewAI AMP. Esta API permite que você interaja programaticamente com seus crews implantados, possibilitando a integração com seus aplicativos, fluxos de trabalho e serviços. ## Início Rápido - Navegue até a página de detalhes do seu crew no painel do CrewAI AOP e copie seu Bearer Token na aba Status. + Navegue até a página de detalhes do seu crew no painel do CrewAI AMP e copie seu Bearer Token na aba Status. @@ -48,7 +48,7 @@ curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \ Você pode encontrar ambos os tipos de token na aba Status da página de - detalhes do seu crew no painel do CrewAI AOP. + detalhes do seu crew no painel do CrewAI AMP. ## URL Base @@ -84,7 +84,7 @@ A API utiliza códigos de status HTTP padrão: ## Testes Interativos - **Por que não há botão "Enviar"?** Como cada usuário do CrewAI AOP possui sua + **Por que não há botão "Enviar"?** Como cada usuário do CrewAI AMP possui sua própria URL de crew, utilizamos o **modo referência** em vez de um playground interativo para evitar confusão. Isso mostra exatamente como as requisições devem ser feitas, sem botões de envio não funcionais. diff --git a/docs/pt-BR/concepts/agents.mdx b/docs/pt-BR/concepts/agents.mdx index f7cc71360..383d501c6 100644 --- a/docs/pt-BR/concepts/agents.mdx +++ b/docs/pt-BR/concepts/agents.mdx @@ -8,6 +8,7 @@ mode: "wide" ## Visão Geral de um Agente No framework CrewAI, um `Agent` é uma unidade autônoma que pode: + - Executar tarefas específicas - Tomar decisões com base em seu papel e objetivo - Utilizar ferramentas para alcançar objetivos @@ -16,15 +17,19 @@ No framework CrewAI, um `Agent` é uma unidade autônoma que pode: - Delegar tarefas, quando permitido -Pense em um agente como um membro especializado da equipe com habilidades, competências e responsabilidades específicas. Por exemplo, um agente `Researcher` pode ser excelente em coletar e analisar informações, enquanto um agente `Writer` pode ser melhor na criação de conteúdo. + Pense em um agente como um membro especializado da equipe com habilidades, + competências e responsabilidades específicas. Por exemplo, um agente + `Researcher` pode ser excelente em coletar e analisar informações, enquanto um + agente `Writer` pode ser melhor na criação de conteúdo. -O CrewAI AOP inclui um Construtor Visual de Agentes, que simplifica a criação e configuração de agentes sem escrever código. Projete seus agentes visualmente e teste-os em tempo real. +O CrewAI AMP inclui um Construtor Visual de Agentes, que simplifica a criação e configuração de agentes sem escrever código. Projete seus agentes visualmente e teste-os em tempo real. ![Visual Agent Builder Screenshot](/images/enterprise/crew-studio-interface.png) O Construtor Visual de Agentes permite: + - Configuração intuitiva de agentes com interfaces baseadas em formulários - Testes e validação em tempo real - Biblioteca de modelos com tipos de agentes pré-configurados @@ -33,36 +38,36 @@ O Construtor Visual de Agentes permite: ## Atributos do Agente -| Atributo | Parâmetro | Tipo | Descrição | -| :-------------------------------------- | :----------------------- | :---------------------------- | :----------------------------------------------------------------------------------------------------------------- | -| **Role (Função)** | `role` | `str` | Define a função e a área de especialização do agente dentro da equipe. | -| **Goal (Objetivo)** | `goal` | `str` | O objetivo individual que guia a tomada de decisão do agente. | -| **Backstory (História de fundo)** | `backstory` | `str` | Fornece contexto e personalidade ao agente, enriquecendo as interações. | -| **LLM** _(opcional)_ | `llm` | `Union[str, LLM, Any]` | Modelo de linguagem que alimenta o agente. Padrão: modelo especificado em `OPENAI_MODEL_NAME` ou "gpt-4". | -| **Tools (Ferramentas)** _(opcional)_ | `tools` | `List[BaseTool]` | Capacidades ou funções disponíveis para o agente. Padrão: lista vazia. | -| **Function Calling LLM** _(opcional)_ | `function_calling_llm` | `Optional[Any]` | Modelo de linguagem usado para chamada de ferramentas, sobrescreve LLM principal se especificado. | -| **Max Iterations** _(opcional)_ | `max_iter` | `int` | Número máximo de iterações antes do agente fornecer sua melhor resposta. Padrão: 20. | -| **Max RPM** _(opcional)_ | `max_rpm` | `Optional[int]` | Quantidade máxima de requisições por minuto para evitar limites de taxa. | -| **Max Execution Time** _(opcional)_ | `max_execution_time` | `Optional[int]` | Tempo máximo (em segundos) de execução da tarefa. | -| **Verbose** _(opcional)_ | `verbose` | `bool` | Habilita logs detalhados de execução para depuração. Padrão: False. | -| **Allow Delegation** _(opcional)_ | `allow_delegation` | `bool` | Permite que o agente delegue tarefas para outros agentes. Padrão: False. | -| **Step Callback** _(opcional)_ | `step_callback` | `Optional[Any]` | Função chamada após cada passo do agente, sobrescreve callback da equipe. | -| **Cache** _(opcional)_ | `cache` | `bool` | Ativa cache para o uso de ferramentas. Padrão: True. | -| **System Template** _(opcional)_ | `system_template` | `Optional[str]` | Template personalizado de prompt de sistema para o agente. | -| **Prompt Template** _(opcional)_ | `prompt_template` | `Optional[str]` | Template de prompt personalizado para o agente. | -| **Response Template** _(opcional)_ | `response_template` | `Optional[str]` | Template de resposta personalizado para o agente. | -| **Allow Code Execution** _(opcional)_ | `allow_code_execution` | `Optional[bool]` | Ativa execução de código pelo agente. Padrão: False. | -| **Max Retry Limit** _(opcional)_ | `max_retry_limit` | `int` | Número máximo de tentativas (retries) em caso de erro. Padrão: 2. | -| **Respect Context Window** _(opcional)_ | `respect_context_window` | `bool` | Mantém as mensagens dentro do tamanho da janela de contexto, resumindo quando necessário. Padrão: True. | -| **Code Execution Mode** _(opcional)_ | `code_execution_mode` | `Literal["safe", "unsafe"]` | Modo de execução de código: 'safe' (usando Docker) ou 'unsafe' (direto). Padrão: 'safe'. | -| **Multimodal** _(opcional)_ | `multimodal` | `bool` | Se o agente suporta capacidades multimodais. Padrão: False. | -| **Inject Date** _(opcional)_ | `inject_date` | `bool` | Se deve injetar automaticamente a data atual nas tarefas. Padrão: False. | -| **Date Format** _(opcional)_ | `date_format` | `str` | Formato de data utilizado quando `inject_date` está ativo. Padrão: "%Y-%m-%d" (formato ISO). | -| **Reasoning** _(opcional)_ | `reasoning` | `bool` | Se o agente deve refletir e criar um plano antes de executar uma tarefa. Padrão: False. | -| **Max Reasoning Attempts** _(opcional)_ | `max_reasoning_attempts` | `Optional[int]` | Número máximo de tentativas de raciocínio antes de executar a tarefa. Se None, tentará até estar pronto. | -| **Embedder** _(opcional)_ | `embedder` | `Optional[Dict[str, Any]]` | Configuração do embedder utilizado pelo agente. | -| **Knowledge Sources** _(opcional)_ | `knowledge_sources` | `Optional[List[BaseKnowledgeSource]]` | Fontes de conhecimento disponíveis para o agente. | -| **Use System Prompt** _(opcional)_ | `use_system_prompt` | `Optional[bool]` | Se deve usar o system prompt (suporte para modelo o1). Padrão: True. | +| Atributo | Parâmetro | Tipo | Descrição | +| :-------------------------------------- | :----------------------- | :------------------------------------ | :-------------------------------------------------------------------------------------------------------- | +| **Role (Função)** | `role` | `str` | Define a função e a área de especialização do agente dentro da equipe. | +| **Goal (Objetivo)** | `goal` | `str` | O objetivo individual que guia a tomada de decisão do agente. | +| **Backstory (História de fundo)** | `backstory` | `str` | Fornece contexto e personalidade ao agente, enriquecendo as interações. | +| **LLM** _(opcional)_ | `llm` | `Union[str, LLM, Any]` | Modelo de linguagem que alimenta o agente. Padrão: modelo especificado em `OPENAI_MODEL_NAME` ou "gpt-4". | +| **Tools (Ferramentas)** _(opcional)_ | `tools` | `List[BaseTool]` | Capacidades ou funções disponíveis para o agente. Padrão: lista vazia. | +| **Function Calling LLM** _(opcional)_ | `function_calling_llm` | `Optional[Any]` | Modelo de linguagem usado para chamada de ferramentas, sobrescreve LLM principal se especificado. | +| **Max Iterations** _(opcional)_ | `max_iter` | `int` | Número máximo de iterações antes do agente fornecer sua melhor resposta. Padrão: 20. | +| **Max RPM** _(opcional)_ | `max_rpm` | `Optional[int]` | Quantidade máxima de requisições por minuto para evitar limites de taxa. | +| **Max Execution Time** _(opcional)_ | `max_execution_time` | `Optional[int]` | Tempo máximo (em segundos) de execução da tarefa. | +| **Verbose** _(opcional)_ | `verbose` | `bool` | Habilita logs detalhados de execução para depuração. Padrão: False. | +| **Allow Delegation** _(opcional)_ | `allow_delegation` | `bool` | Permite que o agente delegue tarefas para outros agentes. Padrão: False. | +| **Step Callback** _(opcional)_ | `step_callback` | `Optional[Any]` | Função chamada após cada passo do agente, sobrescreve callback da equipe. | +| **Cache** _(opcional)_ | `cache` | `bool` | Ativa cache para o uso de ferramentas. Padrão: True. | +| **System Template** _(opcional)_ | `system_template` | `Optional[str]` | Template personalizado de prompt de sistema para o agente. | +| **Prompt Template** _(opcional)_ | `prompt_template` | `Optional[str]` | Template de prompt personalizado para o agente. | +| **Response Template** _(opcional)_ | `response_template` | `Optional[str]` | Template de resposta personalizado para o agente. | +| **Allow Code Execution** _(opcional)_ | `allow_code_execution` | `Optional[bool]` | Ativa execução de código pelo agente. Padrão: False. | +| **Max Retry Limit** _(opcional)_ | `max_retry_limit` | `int` | Número máximo de tentativas (retries) em caso de erro. Padrão: 2. | +| **Respect Context Window** _(opcional)_ | `respect_context_window` | `bool` | Mantém as mensagens dentro do tamanho da janela de contexto, resumindo quando necessário. Padrão: True. | +| **Code Execution Mode** _(opcional)_ | `code_execution_mode` | `Literal["safe", "unsafe"]` | Modo de execução de código: 'safe' (usando Docker) ou 'unsafe' (direto). Padrão: 'safe'. | +| **Multimodal** _(opcional)_ | `multimodal` | `bool` | Se o agente suporta capacidades multimodais. Padrão: False. | +| **Inject Date** _(opcional)_ | `inject_date` | `bool` | Se deve injetar automaticamente a data atual nas tarefas. Padrão: False. | +| **Date Format** _(opcional)_ | `date_format` | `str` | Formato de data utilizado quando `inject_date` está ativo. Padrão: "%Y-%m-%d" (formato ISO). | +| **Reasoning** _(opcional)_ | `reasoning` | `bool` | Se o agente deve refletir e criar um plano antes de executar uma tarefa. Padrão: False. | +| **Max Reasoning Attempts** _(opcional)_ | `max_reasoning_attempts` | `Optional[int]` | Número máximo de tentativas de raciocínio antes de executar a tarefa. Se None, tentará até estar pronto. | +| **Embedder** _(opcional)_ | `embedder` | `Optional[Dict[str, Any]]` | Configuração do embedder utilizado pelo agente. | +| **Knowledge Sources** _(opcional)_ | `knowledge_sources` | `Optional[List[BaseKnowledgeSource]]` | Fontes de conhecimento disponíveis para o agente. | +| **Use System Prompt** _(opcional)_ | `use_system_prompt` | `Optional[bool]` | Se deve usar o system prompt (suporte para modelo o1). Padrão: True. | ## Criando Agentes @@ -137,7 +142,8 @@ class LatestAiDevelopmentCrew(): ``` -Os nomes utilizados em seus arquivos YAML (`agents.yaml`) devem ser iguais aos nomes dos métodos no seu código Python. + Os nomes utilizados em seus arquivos YAML (`agents.yaml`) devem ser iguais aos + nomes dos métodos no seu código Python. ### Definição Direta em Código @@ -183,6 +189,7 @@ agent = Agent( Vamos detalhar algumas combinações de parâmetros-chave para casos de uso comuns: #### Agente de Pesquisa Básico + ```python Code research_agent = Agent( role="Analista de Pesquisa", @@ -194,6 +201,7 @@ research_agent = Agent( ``` #### Agente de Desenvolvimento de Código + ```python Code dev_agent = Agent( role="Desenvolvedor Python Sênior", @@ -207,6 +215,7 @@ dev_agent = Agent( ``` #### Agente de Análise de Longa Duração + ```python Code analysis_agent = Agent( role="Analista de Dados", @@ -220,6 +229,7 @@ analysis_agent = Agent( ``` #### Agente com Template Personalizado + ```python Code custom_agent = Agent( role="Atendente de Suporte ao Cliente", @@ -232,6 +242,7 @@ custom_agent = Agent( ``` #### Agente Ciente de Data, com Raciocínio + ```python Code strategic_agent = Agent( role="Analista de Mercado", @@ -246,6 +257,7 @@ strategic_agent = Agent( ``` #### Agente de Raciocínio + ```python Code reasoning_agent = Agent( role="Planejador Estratégico", @@ -259,6 +271,7 @@ reasoning_agent = Agent( ``` #### Agente Multimodal + ```python Code multimodal_agent = Agent( role="Analista de Conteúdo Visual", @@ -272,52 +285,65 @@ multimodal_agent = Agent( ### Detalhes dos Parâmetros #### Parâmetros Críticos + - `role`, `goal` e `backstory` são obrigatórios e definem o comportamento do agente - `llm` determina o modelo de linguagem utilizado (padrão: GPT-4 da OpenAI) #### Memória e Contexto + - `memory`: Ative para manter o histórico de conversas - `respect_context_window`: Evita problemas com limites de tokens - `knowledge_sources`: Adicione bases de conhecimento específicas do domínio #### Controle de Execução + - `max_iter`: Número máximo de tentativas antes da melhor resposta - `max_execution_time`: Tempo limite em segundos - `max_rpm`: Limite de requisições por minuto - `max_retry_limit`: Tentativas de correção em erros #### Execução de Código + - `allow_code_execution`: Deve ser True para permitir execução de código - `code_execution_mode`: - `"safe"`: Usa Docker (recomendado para produção) - `"unsafe"`: Execução direta (apenas em ambientes confiáveis) - Isso executa uma imagem Docker padrão. Se você deseja configurar a imagem Docker, veja a ferramenta Code Interpreter na seção de ferramentas. - Adicione a ferramenta de interpretação de código como um parâmetro em ferramentas no agente. + Isso executa uma imagem Docker padrão. Se você deseja configurar a imagem + Docker, veja a ferramenta Code Interpreter na seção de ferramentas. Adicione a + ferramenta de interpretação de código como um parâmetro em ferramentas no + agente. #### Funcionalidades Avançadas + - `multimodal`: Habilita capacidades multimodais para processar texto e conteúdo visual - `reasoning`: Permite que o agente reflita e crie planos antes de executar tarefas - `inject_date`: Injeta a data atual automaticamente nas descrições das tarefas #### Templates + - `system_template`: Define o comportamento central do agente - `prompt_template`: Estrutura o formato da entrada - `response_template`: Formata as respostas do agente -Ao usar templates personalizados, assegure-se de definir tanto `system_template` quanto `prompt_template`. O `response_template` é opcional, mas recomendado para formatação consistente de saída. + Ao usar templates personalizados, assegure-se de definir tanto + `system_template` quanto `prompt_template`. O `response_template` é opcional, + mas recomendado para formatação consistente de saída. -Ao usar templates personalizados, você pode usar variáveis como `{role}`, `{goal}` e `{backstory}` em seus templates. Elas serão automaticamente preenchidas durante a execução. + Ao usar templates personalizados, você pode usar variáveis como `{role}`, ` + {goal}` e `{backstory}` em seus templates. Elas serão automaticamente + preenchidas durante a execução. ## Ferramentas do Agente Agentes podem ser equipados com diversas ferramentas para ampliar suas capacidades. O CrewAI suporta ferramentas do: + - [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) - [LangChain Tools](https://python.langchain.com/docs/integrations/tools) @@ -356,7 +382,9 @@ analyst = Agent( ``` -Quando `memory` está ativo, o agente manterá o contexto ao longo de múltiplas interações, melhorando a capacidade de lidar com tarefas complexas, em múltiplos passos. + Quando `memory` está ativo, o agente manterá o contexto ao longo de múltiplas + interações, melhorando a capacidade de lidar com tarefas complexas, em + múltiplos passos. ## Gerenciamento da Janela de Contexto @@ -386,6 +414,7 @@ smart_agent = Agent( ``` **O que acontece quando os limites de contexto são excedidos:** + - ⚠️ **Mensagem de aviso**: `"Context length exceeded. Summarizing content to fit the model context window."` - 🔄 **Resumir automaticamente**: O CrewAI resume o histórico da conversa de forma inteligente - ✅ **Execução contínua**: A execução da tarefa prossegue normalmente com o contexto resumido @@ -407,6 +436,7 @@ strict_agent = Agent( ``` **O que acontece quando os limites de contexto são excedidos:** + - ❌ **Mensagem de erro**: `"Context length exceeded. Consider using smaller text or RAG tools from crewai_tools."` - 🛑 **Execução interrompida**: A execução da tarefa é parada imediatamente - 🔧 **Intervenção manual necessária**: Você precisará modificar sua abordagem @@ -414,6 +444,7 @@ strict_agent = Agent( ### Como Escolher a Melhor Configuração #### Use `respect_context_window=True` (padrão) quando: + - **Processar documentos grandes** que podem ultrapassar os limites de contexto - **Conversas longas** onde certo grau de resumo é aceitável - **Tarefas de pesquisa** onde o contexto geral é mais importante que detalhes exatos @@ -432,6 +463,7 @@ document_processor = Agent( ``` #### Use `respect_context_window=False` quando: + - **Precisão é crítica** e perda de informação é inaceitável - **Tarefas jurídicas ou médicas** que requerem contexto completo - **Revisão de código** onde detalhes perdidos podem causar bugs @@ -454,6 +486,7 @@ precision_agent = Agent( Ao lidar com conjuntos de dados muito grandes, considere as seguintes estratégias: #### 1. Use Ferramentas RAG + ```python Code from crewai_tools import RagTool @@ -471,6 +504,7 @@ rag_agent = Agent( ``` #### 2. Use Fontes de Conhecimento + ```python Code # Use fontes de conhecimento ao invés de prompts grandes knowledge_agent = Agent( @@ -494,6 +528,7 @@ knowledge_agent = Agent( ### Solucionando Problemas de Contexto **Se você receber erros de limite de contexto:** + ```python Code # Solução rápida: Habilite manipulação automática agent.respect_context_window = True @@ -507,6 +542,7 @@ agent.tools = [RagTool()] ``` **Se o resumo automático perder informações importantes:** + ```python Code # Desative o resumo automático e use RAG agent = Agent( @@ -520,28 +556,34 @@ agent = Agent( ``` -O recurso de gerenciamento da janela de contexto funciona automaticamente em segundo plano. Você não precisa chamar funções especiais – basta definir `respect_context_window` conforme deseja e o CrewAI cuida do resto! + O recurso de gerenciamento da janela de contexto funciona automaticamente em + segundo plano. Você não precisa chamar funções especiais – basta definir + `respect_context_window` conforme deseja e o CrewAI cuida do resto! ## Considerações e Boas Práticas Importantes ### Segurança e Execução de Código + - Ao usar `allow_code_execution`, seja cauteloso com entradas do usuário e sempre as valide - Use `code_execution_mode: "safe"` (Docker) em ambientes de produção - Considere definir limites adequados de `max_execution_time` para evitar loops infinitos ### Otimização de Performance + - Use `respect_context_window: true` para evitar problemas com limite de tokens - Ajuste `max_rpm` para evitar rate limiting - Ative `cache: true` para melhorar performance em tarefas repetitivas - Ajuste `max_iter` e `max_retry_limit` conforme a complexidade da tarefa ### Gerenciamento de Memória e Contexto + - Considere `knowledge_sources` para informações específicas de domínio - Configure `embedder` ao usar modelos de embedding personalizados - Use templates personalizados (`system_template`, `prompt_template`, `response_template`) para controle fino do comportamento do agente ### Funcionalidades Avançadas + - Ative `reasoning: true` para agentes que precisam planejar e refletir antes de tarefas complexas - Defina `max_reasoning_attempts` para controlar as iterações de planejamento (`None` para ilimitadas) - Use `inject_date: true` para dar consciência temporal a agentes em tarefas que dependem de datas @@ -549,6 +591,7 @@ O recurso de gerenciamento da janela de contexto funciona automaticamente em seg - Ative `multimodal: true` para agentes que precisam processar texto e imagem ### Colaboração entre Agentes + - Ative `allow_delegation: true` quando agentes precisarem trabalhar juntos - Use `step_callback` para monitorar e registrar interações dos agentes - Considere usar LLMs diferentes para propósitos distintos: @@ -556,6 +599,7 @@ O recurso de gerenciamento da janela de contexto funciona automaticamente em seg - `function_calling_llm` para uso eficiente de ferramentas ### Consciência de Data e Raciocínio + - Use `inject_date: true` para fornecer consciência temporal aos agentes em tarefas sensíveis ao tempo - Customize o formato de data com `date_format` usando códigos standards de datetime do Python - Códigos válidos incluem: %Y (ano), %m (mês), %d (dia), %B (nome completo do mês), etc. @@ -563,22 +607,26 @@ O recurso de gerenciamento da janela de contexto funciona automaticamente em seg - Ative `reasoning: true` para tarefas complexas que se beneficiam de planejamento e reflexão antecipados ### Compatibilidade de Modelos + - Defina `use_system_prompt: false` para modelos antigos que não suportam mensagens de sistema - Certifique-se que o `llm` escolhido suporta as funcionalidades necessárias (como function calling) ## Solução de Problemas Comuns 1. **Limite de Taxa (Rate Limiting)**: Se atingir limites de API: + - Implemente o `max_rpm` adequado - Use cache para operações repetitivas - Considere agrupar requisições em lote 2. **Erros de Janela de Contexto**: Se exceder limites de contexto: + - Habilite `respect_context_window` - Otimize seus prompts - Limpe periodicamente a memória do agente 3. **Problemas de Execução de Código**: Se a execução de código falhar: + - Verifique se o Docker está instalado para o modo seguro - Cheque permissões de execução - Revise as configurações do sandbox de código diff --git a/docs/pt-BR/concepts/cli.mdx b/docs/pt-BR/concepts/cli.mdx index 28a5338aa..1cce9ca03 100644 --- a/docs/pt-BR/concepts/cli.mdx +++ b/docs/pt-BR/concepts/cli.mdx @@ -4,7 +4,14 @@ description: Aprenda a usar o CLI do CrewAI para interagir com o CrewAI. icon: terminal mode: "wide" --- -A partir da versão 0.140.0, a plataforma CrewAI AOP iniciou um processo de migração de seu provedor de login. Como resultado, o fluxo de autenticação via CLI foi atualizado. Usuários que utlizam o Google para fazer login, ou que criaram conta após 3 de julho de 2025 não poderão fazer login com versões anteriores da biblioteca `crewai`. + + + A partir da versão 0.140.0, a plataforma CrewAI AMP iniciou um processo de + migração de seu provedor de login. Como resultado, o fluxo de autenticação via + CLI foi atualizado. Usuários que utlizam o Google para fazer login, ou que + criaram conta após 3 de julho de 2025 não poderão fazer login com versões + anteriores da biblioteca `crewai`. + ## Visão Geral @@ -40,6 +47,7 @@ crewai create [OPTIONS] TYPE NAME - `NAME`: Nome do crew ou flow Exemplo: + ```shell Terminal crewai create crew my_new_crew crewai create flow my_new_flow @@ -56,6 +64,7 @@ crewai version [OPTIONS] - `--tools`: (Opcional) Mostra a versão instalada das ferramentas do CrewAI Exemplo: + ```shell Terminal crewai version crewai version --tools @@ -73,6 +82,7 @@ crewai train [OPTIONS] - `-f, --filename TEXT`: Caminho para um arquivo customizado para treinamento (padrão: "trained_agents_data.pkl") Exemplo: + ```shell Terminal crewai train -n 10 -f my_training_data.pkl ``` @@ -104,6 +114,7 @@ crewai replay [OPTIONS] - `-t, --task_id TEXT`: Reexecuta o crew a partir deste task ID, incluindo todas as tarefas subsequentes Exemplo: + ```shell Terminal crewai replay -t task_123456 ``` @@ -133,6 +144,7 @@ crewai reset-memories [OPTIONS] - `-a, --all`: Redefine TODAS as memórias Exemplo: + ```shell Terminal crewai reset-memories --long --short crewai reset-memories --all @@ -150,6 +162,7 @@ crewai test [OPTIONS] - `-m, --model TEXT`: Modelo LLM para executar os testes no Crew (padrão: "gpt-4o-mini") Exemplo: + ```shell Terminal crewai test -n 5 -m gpt-3.5-turbo ``` @@ -163,12 +176,17 @@ crewai run ``` -A partir da versão 0.103.0, o comando `crewai run` pode ser usado para executar tanto crews padrão quanto flows. Para flows, ele detecta automaticamente o tipo a partir do pyproject.toml e executa o comando apropriado. Este é agora o modo recomendado de executar tanto crews quanto flows. + A partir da versão 0.103.0, o comando `crewai run` pode ser usado para + executar tanto crews padrão quanto flows. Para flows, ele detecta + automaticamente o tipo a partir do pyproject.toml e executa o comando + apropriado. Este é agora o modo recomendado de executar tanto crews quanto + flows. -Certifique-se de executar estes comandos a partir do diretório onde seu projeto CrewAI está configurado. -Alguns comandos podem exigir configuração ou ajustes adicionais dentro da estrutura do seu projeto. + Certifique-se de executar estes comandos a partir do diretório onde seu + projeto CrewAI está configurado. Alguns comandos podem exigir configuração ou + ajustes adicionais dentro da estrutura do seu projeto. ### 9. Chat @@ -180,6 +198,7 @@ Depois de receber os resultados, você pode continuar interagindo com o assisten ```shell Terminal crewai chat ``` + Garanta que você execute estes comandos a partir do diretório raiz do seu projeto CrewAI. @@ -197,28 +216,30 @@ def crew(self) -> Crew: chat_llm="gpt-4o", # LLM para orquestração de chat ) ``` + ### 10. Deploy -Implemente o crew ou flow no [CrewAI AOP](https://app.crewai.com). +Implemente o crew ou flow no [CrewAI AMP](https://app.crewai.com). -- **Autenticação**: Você precisa estar autenticado para implementar no CrewAI AOP. - Você pode fazer login ou criar uma conta com: - ```shell Terminal - crewai login - ``` +- **Autenticação**: Você precisa estar autenticado para implementar no CrewAI AMP. + Você pode fazer login ou criar uma conta com: + + ```shell Terminal + crewai login + ``` - **Criar um deployment**: Depois de autenticado, você pode criar um deployment para seu crew ou flow a partir da raiz do seu projeto local. - ```shell Terminal - crewai deploy create - ``` - - Lê a configuração do seu projeto local. - - Solicita a confirmação das variáveis de ambiente (como `OPENAI_API_KEY`, `SERPER_API_KEY`) encontradas localmente. Elas serão armazenadas de forma segura junto ao deployment na plataforma Enterprise. Verifique se suas chaves sensíveis estão corretamente configuradas localmente (por exemplo, em um arquivo `.env`) antes de executar este comando. + ```shell Terminal + crewai deploy create + ``` + - Lê a configuração do seu projeto local. + - Solicita a confirmação das variáveis de ambiente (como `OPENAI_API_KEY`, `SERPER_API_KEY`) encontradas localmente. Elas serão armazenadas de forma segura junto ao deployment na plataforma Enterprise. Verifique se suas chaves sensíveis estão corretamente configuradas localmente (por exemplo, em um arquivo `.env`) antes de executar este comando. ### 11. Gerenciamento de Organização -Gerencie suas organizações no CrewAI AOP. +Gerencie suas organizações no CrewAI AMP. ```shell Terminal crewai org [COMMAND] [OPTIONS] @@ -227,65 +248,80 @@ crewai org [COMMAND] [OPTIONS] #### Comandos: - `list`: Liste todas as organizações das quais você faz parte + ```shell Terminal crewai org list ``` - `current`: Exibe sua organização ativa atualmente + ```shell Terminal crewai org current ``` - `switch`: Mude para uma organização específica + ```shell Terminal crewai org switch ``` -Você deve estar autenticado no CrewAI AOP para usar estes comandos de gerenciamento de organização. + Você deve estar autenticado no CrewAI AMP para usar estes comandos de + gerenciamento de organização. - **Criar um deployment** (continuação): - - Vincula o deployment ao respectivo repositório remoto do GitHub (normalmente detectado automaticamente). -- **Implantar o Crew**: Depois de autenticado, você pode implantar seu crew ou flow no CrewAI AOP. - ```shell Terminal - crewai deploy push - ``` - - Inicia o processo de deployment na plataforma CrewAI AOP. - - Após a iniciação bem-sucedida, será exibida a mensagem Deployment created successfully! juntamente com o Nome do Deployment e um Deployment ID (UUID) único. + - Vincula o deployment ao respectivo repositório remoto do GitHub (normalmente detectado automaticamente). + +- **Implantar o Crew**: Depois de autenticado, você pode implantar seu crew ou flow no CrewAI AMP. + + ```shell Terminal + crewai deploy push + ``` + + - Inicia o processo de deployment na plataforma CrewAI AMP. + - Após a iniciação bem-sucedida, será exibida a mensagem Deployment created successfully! juntamente com o Nome do Deployment e um Deployment ID (UUID) único. - **Status do Deployment**: Você pode verificar o status do seu deployment com: - ```shell Terminal - crewai deploy status - ``` - Isso retorna o status mais recente do último deployment iniciado (por exemplo, `Building Images for Crew`, `Deploy Enqueued`, `Online`). + + ```shell Terminal + crewai deploy status + ``` + + Isso retorna o status mais recente do último deployment iniciado (por exemplo, `Building Images for Crew`, `Deploy Enqueued`, `Online`). - **Logs do Deployment**: Você pode checar os logs do seu deployment com: - ```shell Terminal - crewai deploy logs - ``` - Isso faz o streaming dos logs do deployment para seu terminal. + + ```shell Terminal + crewai deploy logs + ``` + + Isso faz o streaming dos logs do deployment para seu terminal. - **Listar deployments**: Você pode listar todos os seus deployments com: - ```shell Terminal - crewai deploy list - ``` - Isto lista todos os seus deployments. + + ```shell Terminal + crewai deploy list + ``` + + Isto lista todos os seus deployments. - **Deletar um deployment**: Você pode deletar um deployment com: - ```shell Terminal - crewai deploy remove - ``` - Isto exclui o deployment da plataforma CrewAI AOP. + + ```shell Terminal + crewai deploy remove + ``` + + Isto exclui o deployment da plataforma CrewAI AMP. - **Comando de Ajuda**: Você pode obter ajuda sobre o CLI com: - ```shell Terminal - crewai deploy --help - ``` - Isto exibe a mensagem de ajuda para o CLI CrewAI Deploy. + ```shell Terminal + crewai deploy --help + ``` + Isto exibe a mensagem de ajuda para o CLI CrewAI Deploy. -Assista ao vídeo tutorial para uma demonstração passo-a-passo de implantação do seu crew no [CrewAI AOP](http://app.crewai.com) usando o CLI. +Assista ao vídeo tutorial para uma demonstração passo-a-passo de implantação do seu crew no [CrewAI AMP](http://app.crewai.com) usando o CLI. ## Tutorial em Texto + **Requisitos de Versão do Python** - CrewAI requer `Python >=3.10 e <3.14`. Veja como verificar sua versão: - ```bash - python3 --version - ``` +CrewAI requer `Python >=3.10 e <3.14`. Veja como verificar sua versão: + +```bash +python3 --version +``` + +Se você precisar atualizar o Python, acesse [python.org/downloads](https://python.org/downloads) - Se você precisar atualizar o Python, acesse [python.org/downloads](https://python.org/downloads) CrewAI utiliza o `uv` como ferramenta de gerenciamento de dependências e pacotes. Ele simplifica a configuração e execução do projeto, oferecendo uma experiência fluida. @@ -89,6 +93,7 @@ Se você ainda não instalou o `uv`, siga o **passo 1** para instalá-lo rapidam ``` Instalação realizada com sucesso! Você está pronto para criar seu primeiro crew! 🎉 + # Criando um Projeto CrewAI @@ -124,6 +129,7 @@ Recomendamos utilizar o template de scaffolding `YAML` para uma abordagem estrut └── tasks.yaml ``` + @@ -140,6 +146,7 @@ Recomendamos utilizar o template de scaffolding `YAML` para uma abordagem estrut - Comece editando `agents.yaml` e `tasks.yaml` para definir o comportamento do seu crew. - Mantenha informações sensíveis como chaves de API no arquivo `.env`. + @@ -163,13 +170,15 @@ Recomendamos utilizar o template de scaffolding `YAML` para uma abordagem estrut Para equipes e organizações, o CrewAI oferece opções de implantação corporativa que eliminam a complexidade da configuração: -### CrewAI AOP (SaaS) +### CrewAI AMP (SaaS) + - Zero instalação necessária - basta se cadastrar gratuitamente em [app.crewai.com](https://app.crewai.com) - Atualizações e manutenção automáticas - Infraestrutura e escalabilidade gerenciadas - Construa crews sem código ### CrewAI Factory (Auto-Hospedado) + - Implantação containerizada para sua infraestrutura - Compatível com qualquer hyperscaler, incluindo ambientes on-premises - Integração com seus sistemas de segurança existentes @@ -187,13 +196,15 @@ Para equipes e organizações, o CrewAI oferece opções de implantação corpor icon="code" href="/pt-BR/quickstart" > - Siga nosso guia de início rápido para criar seu primeiro agente CrewAI e obter experiência prática. + Siga nosso guia de início rápido para criar seu primeiro agente CrewAI e + obter experiência prática. - Conecte-se com outros desenvolvedores, obtenha ajuda e compartilhe suas experiências com o CrewAI. + Conecte-se com outros desenvolvedores, obtenha ajuda e compartilhe suas + experiências com o CrewAI. diff --git a/docs/pt-BR/learn/llm-selection-guide.mdx b/docs/pt-BR/learn/llm-selection-guide.mdx index 07ca4a1e0..ce85c3351 100644 --- a/docs/pt-BR/learn/llm-selection-guide.mdx +++ b/docs/pt-BR/learn/llm-selection-guide.mdx @@ -1,7 +1,7 @@ --- -title: 'Guia Estratégico de Seleção de LLMs' -description: 'Framework estratégico para escolher o LLM certo para seus agentes CrewAI e escrever definições eficazes de tarefas e agentes' -icon: 'brain-circuit' +title: "Guia Estratégico de Seleção de LLMs" +description: "Framework estratégico para escolher o LLM certo para seus agentes CrewAI e escrever definições eficazes de tarefas e agentes" +icon: "brain-circuit" mode: "wide" --- @@ -10,23 +10,36 @@ mode: "wide" Em vez de recomendações prescritivas de modelos, defendemos um **framework de pensamento** que ajude você a tomar decisões informadas com base no seu caso de uso, restrições e requisitos específicos. O cenário de LLMs evolui rapidamente, com novos modelos surgindo regularmente e os existentes sendo atualizados frequentemente. O que mais importa é desenvolver uma abordagem sistemática de avaliação que permaneça relevante independentemente dos modelos disponíveis no momento. -Este guia foca em pensamento estratégico em vez de recomendações de modelos específicos, já que o cenário dos LLMs evolui rapidamente. + Este guia foca em pensamento estratégico em vez de recomendações de modelos + específicos, já que o cenário dos LLMs evolui rapidamente. ## Framework de Decisão Rápida - Comece entendendo profundamente o que suas tarefas realmente exigem. Considere a complexidade cognitiva envolvida, a profundidade de raciocínio necessária, o formato dos resultados esperados e a quantidade de contexto que o modelo precisará processar. Essa análise fundamental guiará todas as decisões seguintes. + Comece entendendo profundamente o que suas tarefas realmente exigem. + Considere a complexidade cognitiva envolvida, a profundidade de raciocínio + necessária, o formato dos resultados esperados e a quantidade de contexto + que o modelo precisará processar. Essa análise fundamental guiará todas as + decisões seguintes. - Assim que você compreende seus requisitos, mapeie-os para as forças dos modelos. Diferentes famílias de modelos se destacam em diferentes tipos de trabalho; alguns são otimizados para raciocínio e análise, outros para criatividade e geração de conteúdo, e outros para velocidade e eficiência. + Assim que você compreende seus requisitos, mapeie-os para as forças dos + modelos. Diferentes famílias de modelos se destacam em diferentes tipos de + trabalho; alguns são otimizados para raciocínio e análise, outros para + criatividade e geração de conteúdo, e outros para velocidade e eficiência. - Leve em conta suas reais restrições operacionais, incluindo limitações orçamentárias, requisitos de latência, necessidades de privacidade de dados e capacidades de infraestrutura. O melhor modelo teoricamente pode não ser a melhor escolha prática para sua situação. + Leve em conta suas reais restrições operacionais, incluindo limitações + orçamentárias, requisitos de latência, necessidades de privacidade de dados + e capacidades de infraestrutura. O melhor modelo teoricamente pode não ser a + melhor escolha prática para sua situação. - Comece com modelos confiáveis e bem conhecidos e otimize com base no desempenho real no seu caso de uso. Os resultados práticos frequentemente diferem dos benchmarks teóricos, então testes empíricos são cruciais. + Comece com modelos confiáveis e bem conhecidos e otimize com base no + desempenho real no seu caso de uso. Os resultados práticos frequentemente + diferem dos benchmarks teóricos, então testes empíricos são cruciais. @@ -43,6 +56,7 @@ O passo mais crítico na seleção de LLMs é entender o que sua tarefa realment - **Tarefas Complexas** exigem raciocínio de múltiplas etapas, pensamento estratégico e a capacidade de lidar com informações ambíguas ou incompletas. Podem envolver análise de múltiplas fontes de dados, desenvolvimento de estratégias abrangentes ou resolução de problemas que precisam ser decompostos em componentes menores. O modelo deve manter o contexto ao longo de várias etapas de raciocínio e frequentemente precisa inferir informações não explicitamente declaradas. - **Tarefas Criativas** exigem um tipo diferente de capacidade cognitiva, focada em gerar conteúdo novo, envolvente e adequado ao contexto. Isso inclui storytelling, criação de textos de marketing e solução criativa de problemas. O modelo deve compreender nuances, tom e público, produzindo conteúdo autêntico e envolvente, não apenas fórmulas. + @@ -51,6 +65,7 @@ O passo mais crítico na seleção de LLMs é entender o que sua tarefa realment - **Conteúdo Criativo** requer equilíbrio entre competência técnica e criatividade. O modelo precisa compreender o público, tom e voz da marca, ao mesmo tempo em que produz conteúdo que engaja leitores e atinge objetivos comunicativos específicos. A qualidade aqui é mais subjetiva e exige modelos capazes de adaptar o estilo de escrita a diferentes contextos e propósitos. - **Conteúdo Técnico** situa-se entre dados estruturados e conteúdo criativo, demandando precisão e clareza. Documentação, geração de código e análises técnicas precisam ser exatas e completas, mas ainda assim acessíveis ao público-alvo. O modelo deve entender conceitos técnicos complexos e comunicá-los de forma eficaz. + @@ -59,6 +74,7 @@ O passo mais crítico na seleção de LLMs é entender o que sua tarefa realment - **Contexto Longo** é necessário ao lidar com documentos substanciais, conversas extensas ou tarefas complexas de múltiplas partes. O modelo precisa manter coerência ao longo de milhares de tokens, referenciando informações anteriores com precisão. Essencial para análise de documentos, pesquisa abrangente e sistemas de diálogo sofisticados. - **Contexto Muito Longo** ultrapassa os limites do possível hoje, com processamento de documentos massivos, síntese de pesquisas extensas ou interações multi-sessão. São casos que exigem modelos projetados especificamente para lidar com contexto estendido e envolvem trade-offs entre extensão e velocidade. + @@ -73,6 +89,7 @@ Entender as capacidades dos modelos exige ir além do marketing e dos benchmarks O ponto forte é manter consistência lógica em cadeias longas de raciocínio e decompor problemas complexos em partes gerenciáveis. São especialmente valiosos para planejamento estratégico, análise complexa e situações onde a qualidade do raciocínio importa mais que a velocidade. Entretanto, há trade-offs em termos de custo e velocidade. Podem ser menos adequados para tarefas criativas ou operações simples, onde suas capacidades avançadas não são necessárias. Considere-os quando as tarefas realmente se beneficiarem dessa análise detalhada. + @@ -81,6 +98,7 @@ Entender as capacidades dos modelos exige ir além do marketing e dos benchmarks A principal vantagem é a confiabilidade previsível em diversos trabalhos: pesquisa, análise, criação de conteúdo, processamento de dados. São ótimas opções iniciais para equipes que buscam consistência ao lidar com fluxos variados. Embora não atinjam picos de desempenho como modelos especializados, oferecem simplicidade operacional e baixa complexidade na gestão. São o melhor ponto de partida para novos projetos, permitindo descobertas de necessidades antes de avançar para otimizações. + @@ -89,6 +107,7 @@ Entender as capacidades dos modelos exige ir além do marketing e dos benchmarks Brilham em operações rotineiras, processamento simples de dados, chamadas de funções e tarefas de alto volume. Aplicações que processam muitos pedidos rapidamente ou operam sob restrições orçamentárias se beneficiam desses modelos. O ponto crucial é garantir que suas capacidades atendam às exigências da tarefa. Podem não atender tarefas que exijam entendimento profundo, raciocínio complexo ou geração de conteúdo sofisticado. São ideais para tarefas rotineiras bem definidas. + @@ -97,6 +116,7 @@ Entender as capacidades dos modelos exige ir além do marketing e dos benchmarks O ponto forte está em adaptar o estilo para diferentes públicos, manter voz e tom consistentes e engajar leitores. Performam melhor em storytelling, textos publicitários, comunicações de marca e outras tarefas com criatividade como foco. Ao selecionar esses modelos, considere não apenas a habilidade de gerar texto, mas a compreensão de público, contexto e objetivo. Os melhores modelos criativos adaptam a saída à voz da marca, diferentes segmentos e mantêm consistência em peças longas. + @@ -105,6 +125,7 @@ Entender as capacidades dos modelos exige ir além do marketing e dos benchmarks Os principais benefícios incluem eliminação de custos por token, possibilidade de fine-tuning, privacidade total e independência de fornecedores externos. Perfeitos para organizações com necessidade de privacidade, orçamento limitado ou desejo de customização. Contudo, requerem maior expertise técnica para implantar e manter. Considere custos de infraestrutura, complexidade de gestão e esforços contínuos de atualização e otimização ao avaliar modelos open source. O custo total pode ser maior que o de alternativas em nuvem devido a esse overhead. + @@ -113,7 +134,8 @@ Entender as capacidades dos modelos exige ir além do marketing e dos benchmarks ### a. Abordagem Multi-Modelo -Use diferentes modelos para diferentes propósitos dentro da mesma crew para otimizar desempenho e custos. + Use diferentes modelos para diferentes propósitos dentro da mesma crew para + otimizar desempenho e custos. As implementações CrewAI mais sofisticadas empregam múltiplos modelos estrategicamente, designando-os conforme as funções e necessidades dos agentes. Assim, é possível otimizar desempenho e custos usando o modelo mais adequado para cada tipo de tarefa. @@ -177,6 +199,7 @@ O segredo do sucesso na implementação multi-modelo está em entender como os a LLMs de manager eficazes exigem forte raciocínio para delegar bem, desempenho consistente para coordenar previsivelmente e excelente gestão de contexto para acompanhar o estado dos agentes. O modelo deve entender capacidades e limitações dos agentes enquanto otimiza a alocação de tarefas. O custo é especialmente relevante, já que este LLM participa de todas as operações. O modelo precisa entregar capacidades suficientes, sem o preço premium de opções sofisticadas demais, buscando sempre o equilíbrio entre performance e valor. + @@ -185,6 +208,7 @@ O segredo do sucesso na implementação multi-modelo está em entender como os a As características mais importantes são precisão e confiabilidade, não criatividade ou raciocínio avançado. O modelo deve extrair parâmetros corretos de comandos em linguagem natural consistentemente e processar respostas de ferramentas adequadamente. Velocidade também importa, pois o uso de ferramentas pode envolver múltiplas idas e vindas de informação. Muitas equipes descobrem que modelos especializados em function calling ou de uso geral com forte suporte a ferramentas funcionam melhor do que modelos criativos ou de raciocínio nesse papel. O fundamental é assegurar que o modelo consiga converter instruções em chamadas estruturadas sem falhas. + @@ -193,6 +217,7 @@ O segredo do sucesso na implementação multi-modelo está em entender como os a Considere sobrescritas quando a função do agente exige capacidades distintas. Por exemplo, um agente de redação criativa pode se beneficiar de um LLM otimizado para geração de conteúdo, enquanto um analista de dados pode preferir um modelo voltado ao raciocínio. O desafio é balancear otimização com complexidade operacional. Cada modelo adicional aumenta a complexidade de deployment, monitoramento e custos. Foque em sobrescritas apenas quando a melhoria justificar essa complexidade. + @@ -209,6 +234,7 @@ Definir bem as tarefas é frequentemente mais importante do que a seleção do m Descrições eficazes incluem contexto relevante e restrições, ajudando o agente a entender o propósito maior e quaisquer limitações. Divida trabalhos complexos em etapas gerenciáveis em vez de objetivos genéricos e sobrecarregados. Erros comuns incluem objetivos vagos, falta de contexto, critérios de sucesso mal definidos ou mistura de tarefas totalmente distintas em um mesmo texto. O objetivo é passar informação suficiente para o sucesso, mas mantendo foco no resultado claro. + @@ -217,6 +243,7 @@ Definir bem as tarefas é frequentemente mais importante do que a seleção do m As melhores diretrizes incluem exemplos concretos de indicadores de qualidade e critérios claros de conclusão, de modo que agente e revisores humanos possam avaliar o resultado facilmente. Isso reduz ambiguidades e garante resultados consistentes. Evite descrições genéricas que serviriam para qualquer tarefa, ausência de especificações de formato, padrões vagos ou falta de exemplos/modelos que ajudem o agente a entender as expectativas. + @@ -229,6 +256,7 @@ Definir bem as tarefas é frequentemente mais importante do que a seleção do m Para implementar bem, use o parâmetro de contexto para encadear tarefas, desenvolvendo gradualmente a complexidade. Cada tarefa deve gerar saídas que alimentam as próximas. O objetivo é manter um fluxo lógico entre as tarefas dependentes, evitando gargalos desnecessários. Funciona melhor quando há progressão lógica evidente e quando a saída de uma tarefa realmente agrega valor nas etapas seguintes. Cuidado com os gargalos; foque nas dependências essenciais. + @@ -237,6 +265,7 @@ Definir bem as tarefas é frequentemente mais importante do que a seleção do m Para isso, identifique tarefas realmente independentes, agrupe fluxos de trabalho distintos e planeje a integração dos resultados posteriormente. O ponto-chave é garantir que tarefas paralelas não gerem conflitos ou redundâncias. Considere o paralelo em múltiplos fluxos independentes, diferentes tipos de análise autônoma, ou criação de conteúdo que pode ser feita ao mesmo tempo. Mas atente-se à alocação de recursos, evitando sobrecarga de modelos ou estouro no orçamento. + @@ -245,7 +274,8 @@ Definir bem as tarefas é frequentemente mais importante do que a seleção do m ### a. Seleção de LLM Guiada pelo Papel -Funções genéricas de agentes tornam impossível escolher o LLM certo. Funções específicas permitem otimização do modelo conforme a função. + Funções genéricas de agentes tornam impossível escolher o LLM certo. Funções + específicas permitem otimização do modelo conforme a função. A especificidade das funções dos agentes determina quais capacidades de LLM mais importam para alto desempenho, criando oportunidade estratégica de alinhar forças do modelo ao papel do agente. @@ -253,6 +283,7 @@ A especificidade das funções dos agentes determina quais capacidades de LLM ma **Impacto de Funções Genéricas vs. Específicas:** Ao definir funções, pense no conhecimento do domínio, estilo de trabalho e frameworks decisórios mais valiosos para o tipo de tarefa do agente. Quanto mais específica e contextualizada a função, melhor o modelo incorporará esse papel. + ```python # ✅ Função específica - requisitos claros de LLM specific_agent = Agent( @@ -273,7 +304,8 @@ specific_agent = Agent( ### b. Backstory como Amplificador de Contexto do Modelo -Backstories estratégicos maximizam a eficácia do LLM ao contextualizar as respostas de forma que prompts genéricos não conseguem. + Backstories estratégicos maximizam a eficácia do LLM ao contextualizar as + respostas de forma que prompts genéricos não conseguem. Um bom backstory transforma a escolha do LLM de genérica a especializada. Isso é crucial para otimizar custos: um modelo eficiente com contexto certo pode superar um premium sem contexto. @@ -300,6 +332,7 @@ domain_expert = Agent( ``` **Elementos de Backstory que Potencializam a Performance de LLMs:** + - **Experiência de Domínio**: "10+ anos em vendas enterprise SaaS" - **Expertise Específica**: "Especialista em due diligence técnica para Série B+" - **Estilo de Trabalho**: "Decisões orientadas a dados, documentação clara" @@ -332,6 +365,7 @@ tech_writer = Agent( ``` **Checklist de Alinhamento:** + - ✅ **Função Específica**: Domínio e responsabilidades claras - ✅ **Correspondência do LLM**: Forças do modelo conectadas à função - ✅ **Profundidade do Backstory**: Contexto de domínio disponível pro modelo @@ -353,6 +387,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl - Algum agente depende fortemente de ferramentas? **Ação**: Documente funções dos agentes e identifique oportunidades de otimização. + @@ -369,6 +404,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl ``` **Ação**: Defina o LLM padrão da crew antes de otimizar agentes individuais. + @@ -390,16 +426,18 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl ``` **Ação**: Faça upgrade dos 20% dos agentes que tratam 80% da complexidade. + **Após colocar os agentes em produção:** - - Use [CrewAI AOP platform](https://app.crewai.com) para testar seleções de modelo A/B + - Use [CrewAI AMP platform](https://app.crewai.com) para testar seleções de modelo A/B - Execute múltiplas iterações com inputs reais para medir consistência e performance - Compare custo vs performance na configuração otimizada - Compartilhe resultados com o time para tomada coletiva de decisão **Ação**: Substitua achismos por validação com dados reais usando a plataforma de testes. + @@ -412,6 +450,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl Considere-os para desenvolvimento de estratégias de negócios, análise de dados combinados de múltiplas fontes, resolução de problemas dependente de etapas sucessivas e planejamento estratégico envolvendo múltiplas variáveis. Entretanto, esses modelos são mais caros e lentos, devendo ser reservados para tarefas onde suas capacidades agregam valor real — evite usá-los apenas para operações simples. + @@ -420,6 +459,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl Use-os em redação de posts, criação de artigos, textos de marketing com viés persuasivo, storytelling e comunicações da marca. Costumam captar nuances e contexto melhor do que generalistas. Podem ser menos adequados para tarefas técnicas ou analíticas, onde precisão supera criatividade. Use-os quando aspectos comunicativos são fatores críticos de sucesso. + @@ -428,6 +468,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl Considere-os para processamento e transformação de dados, formatação simples, chamadas de funções (function calling) e operações em alto volume onde custo importa mais. O ponto crítico é verificar adequação à tarefa. Funcionam para muitos fluxos rotineiros, mas podem falhar se a tarefa exigir compreensão técnica ou raciocínio. + @@ -436,6 +477,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl Considere para ferramentas internas de empresas, aplicações sensíveis, projetos onde não é possível usar APIs externas, casos com orçamento apertado ou requisitos de customização. Mas lembre-se: exigem mais expertise, manutenção e investimentos em infraestrutura. Avalie o custo total da operação ao avaliar esses modelos. + @@ -455,6 +497,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl # Agente de processamento recebe modelo eficiente processor = Agent(role="Data Processor", llm=LLM(model="gpt-4o-mini")) ``` + @@ -474,6 +517,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl # Agentes herdam o LLM da crew, salvo sobrescrita agent1 = Agent(llm=LLM(model="claude-3-5-sonnet")) ``` + @@ -492,6 +536,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl llm=LLM(model="claude-3-5-sonnet") ) ``` + @@ -507,6 +552,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl # Teste a performance e só depois otimize agentes específicos # Use testes Enterprise para validar melhorias ``` + @@ -515,6 +561,7 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl **Exemplo real**: Usar modelo de contexto curto para agentes que precisam manter histórico ao longo de múltiplas iterações ou equipes com comunicação extensiva agent-to-agent. **Solução CrewAI**: Alinhe capacidades de contexto ao padrão de comunicação da crew. + @@ -522,26 +569,36 @@ Em vez de repetir o framework estratégico, segue um checklist tático para impl - Comece com modelos de uso geral, confiáveis e amplamente suportados. Isso estabelece base estável para entender necessidades e expectativas de desempenho antes de otimizar para demandas especializadas. + Comece com modelos de uso geral, confiáveis e amplamente suportados. Isso + estabelece base estável para entender necessidades e expectativas de + desempenho antes de otimizar para demandas especializadas. - Desenvolva métricas alinhadas ao seu caso de uso e metas de negócio, não apenas benchmarks gerais. Foque na mensuração de resultados relevantes ao seu sucesso. + Desenvolva métricas alinhadas ao seu caso de uso e metas de negócio, não + apenas benchmarks gerais. Foque na mensuração de resultados relevantes ao + seu sucesso. - Faça mudanças baseadas no desempenho observado no seu contexto, não apenas considerações teóricas ou recomendações genéricas. O desempenho prático costuma ser bem diferente dos benchmarks. + Faça mudanças baseadas no desempenho observado no seu contexto, não apenas + considerações teóricas ou recomendações genéricas. O desempenho prático + costuma ser bem diferente dos benchmarks. - Avalie todo custo de operação, incluindo modelo, tempo de desenvolvimento, manutenção e complexidade. O modelo mais barato por token pode não ser o mais econômico ao considerar todos os fatores. + Avalie todo custo de operação, incluindo modelo, tempo de desenvolvimento, + manutenção e complexidade. O modelo mais barato por token pode não ser o + mais econômico ao considerar todos os fatores. -Foque em entender seus requisitos primeiro, e então escolha modelos que melhor correspondam a essas necessidades. O melhor LLM é aquele que consistentemente entrega os resultados esperados dentro das suas restrições. + Foque em entender seus requisitos primeiro, e então escolha modelos que melhor + correspondam a essas necessidades. O melhor LLM é aquele que consistentemente + entrega os resultados esperados dentro das suas restrições. ### Validação de Modelos em Nível Enterprise -Para equipes sérias sobre otimização, a **plataforma CrewAI AOP** oferece testes sofisticados que vão além do CLI. Ela permite avaliação completa para decisões orientadas por dados na estratégia de LLM. +Para equipes sérias sobre otimização, a **plataforma CrewAI AMP** oferece testes sofisticados que vão além do CLI. Ela permite avaliação completa para decisões orientadas por dados na estratégia de LLM. ![Enterprise Testing Interface](/images/enterprise/enterprise-testing.png) @@ -562,7 +619,9 @@ Para equipes sérias sobre otimização, a **plataforma CrewAI AOP** oferece tes Acesse [app.crewai.com](https://app.crewai.com) para começar! -A plataforma Enterprise transforma a seleção de modelos de um "palpite" para um processo orientado por dados, permitindo validar os princípios deste guia com seus próprios casos de uso. + A plataforma Enterprise transforma a seleção de modelos de um "palpite" para + um processo orientado por dados, permitindo validar os princípios deste guia + com seus próprios casos de uso. ## Resumo dos Princípios-Chave @@ -572,21 +631,27 @@ A plataforma Enterprise transforma a seleção de modelos de um "palpite" para u Escolha os modelos pelo que sua tarefa realmente requer, não por reputação ou capacidades teóricas. - - Alinhe forças do modelo a papéis e responsabilidades dos agentes para melhor desempenho. - +{" "} + + Alinhe forças do modelo a papéis e responsabilidades dos agentes para melhor + desempenho. + - - Mantenha uma estratégia coerente de seleção de modelos em fluxos e componentes relacionados. - +{" "} + + Mantenha uma estratégia coerente de seleção de modelos em fluxos e componentes + relacionados. + - - Valide escolhas em uso real, não apenas em benchmarks. - +{" "} + + Valide escolhas em uso real, não apenas em benchmarks. + - - Comece simples e otimize com base na performance e necessidade práticas. - +{" "} + + Comece simples e otimize com base na performance e necessidade práticas. + Equilibre performance requerida, custo e complexidade. @@ -594,13 +659,19 @@ A plataforma Enterprise transforma a seleção de modelos de um "palpite" para u -Lembre-se: o melhor LLM é o que entrega consistentemente os resultados de que você precisa dentro de suas restrições. Conheça seu requisito primeiro, depois selecione o modelo mais adequado. + Lembre-se: o melhor LLM é o que entrega consistentemente os resultados de que + você precisa dentro de suas restrições. Conheça seu requisito primeiro, depois + selecione o modelo mais adequado. ## Panorama Atual dos Modelos (Junho/2025) -**Retrato do Momento**: Os rankings a seguir representam o estado da arte em Junho de 2025, compilados do [LMSys Arena](https://arena.lmsys.org/), [Artificial Analysis](https://artificialanalysis.ai/) e outros benchmarks líderes. Performance, disponibilidade e preço mudam rapidamente. Sempre valide com seus dados e casos reais. + **Retrato do Momento**: Os rankings a seguir representam o estado da arte em + Junho de 2025, compilados do [LMSys Arena](https://arena.lmsys.org/), + [Artificial Analysis](https://artificialanalysis.ai/) e outros benchmarks + líderes. Performance, disponibilidade e preço mudam rapidamente. Sempre valide + com seus dados e casos reais. ### Principais Modelos por Categoria @@ -608,7 +679,9 @@ Lembre-se: o melhor LLM é o que entrega consistentemente os resultados de que v As tabelas abaixo mostram uma amostra dos modelos de maior destaque em cada categoria, junto de orientação sobre aplicação em agentes CrewAI: -Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muitos outros excelentes. O objetivo é ilustrar exemplos de capacidades buscadas em vez de apresentar um catálogo completo. + Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem + muitos outros excelentes. O objetivo é ilustrar exemplos de capacidades + buscadas em vez de apresentar um catálogo completo. @@ -624,6 +697,7 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito | **Qwen3 235B (Reasoning)** | 62 | $2.63 | Moderada | Alternativa open source para raciocínio | Esses modelos se destacam em raciocínio multi-etapas e são ideais para agentes que desenvolvem estratégias, coordenam outros agentes ou analisam informações complexas. + @@ -638,6 +712,7 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito | **Llama 3.1 405B** | Bom | 81.1% | $3.50 | LLM para function calling em workflows intensivos em ferramentas | Otimizados para geração de código, debugging e solução técnica, ideais para equipes de desenvolvimento. + @@ -652,6 +727,7 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito | **Nova Micro** | Alto | 0.30s | $0.04 | Execução rápida de tarefas simples | Priorizam velocidade e eficiência, perfeitos para agentes em operações de rotina ou resposta ágil. **Dica:** Usar provedores de inference rápidos como Groq potencializa open source como Llama. + @@ -666,6 +742,7 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito | **Qwen3 32B** | 44 | Boa | $1.23 | Versatilidade econômica | Oferecem bom desempenho geral, adequados para crews com demandas amplas. + @@ -676,24 +753,28 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito **Priorizando performance**: Use modelos topo de linha como **o3**, **Gemini 2.5 Pro** ou **Claude 4 Sonnet** para managers e agentes críticos. Excelentes em raciocínio e coordenação, porém mais caros. **Estratégia**: Implemente abordagem multi-modelo, reservando premium para raciocínio estratégico e eficientes para operações rotineiras. + **Foco no orçamento**: Foque em modelos como **DeepSeek R1**, **Llama 4 Scout** ou **Gemini 2.0 Flash**, que trazem ótimo desempenho com investimento reduzido. **Estratégia**: Use modelos econômicos para maioria dos agentes, reservando premium apenas para funções críticas. + **Para expertise específica**: Escolha modelos otimizados para seu principal caso de uso: **Claude 4** em código, **Gemini 2.5 Pro** em pesquisa, **Llama 405B** em function calling. **Estratégia**: Selecione conforme a principal função da crew, garantindo alinhamento de capacidade e modelo. + **Para operações sensíveis**: Avalie modelos open source como **Llama 4** series, **DeepSeek V3** ou **Qwen3** para deployment privado, mantendo performance competitiva. **Estratégia**: Use open source em infraestrutura própria e aceite possíveis trade-offs por controle dos dados. + @@ -704,7 +785,9 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito - **Viabilidade Open Source**: A distância entre open source e proprietários diminui a cada mês, com Llama 4 Maverick e DeepSeek V3 entregando performance competitiva a preços atrativos. Inferência rápida via Groq maximiza custo-benefício nesses casos. -**Testes são essenciais**: Rankings servem de orientação geral, mas seu caso de uso, prompt e critério podem gerar resultados distintos. Sempre teste modelos candidatos com suas tarefas e dados reais antes de decidir. + **Testes são essenciais**: Rankings servem de orientação geral, mas seu caso + de uso, prompt e critério podem gerar resultados distintos. Sempre teste + modelos candidatos com suas tarefas e dados reais antes de decidir. ### Estratégia Prática de Implementação @@ -714,13 +797,19 @@ Estas tabelas exibem apenas alguns modelos líderes por categoria. Existem muito Inicie com opções consagradas como **GPT-4.1**, **Claude 3.7 Sonnet** ou **Gemini 2.0 Flash**, que oferecem bom desempenho e ampla validação. - - Descubra se sua crew possui requisitos específicos (código, raciocínio, velocidade) que justifiquem modelos como **Claude 4 Sonnet** para desenvolvimento ou **o3** para análise. Para aplicações críticas em velocidade, considere Groq aliado à seleção do modelo. - +{" "} + + Descubra se sua crew possui requisitos específicos (código, raciocínio, + velocidade) que justifiquem modelos como **Claude 4 Sonnet** para + desenvolvimento ou **o3** para análise. Para aplicações críticas em + velocidade, considere Groq aliado à seleção do modelo. + - - Use modelos diferentes para agentes distintos conforme o papel. Modelos de alta capacidade para managers e tarefas complexas, eficientes para rotinas. - +{" "} + + Use modelos diferentes para agentes distintos conforme o papel. Modelos de + alta capacidade para managers e tarefas complexas, eficientes para rotinas. + Acompanhe métricas relevantes ao seu caso e esteja pronto para ajustar modelos conforme lançamentos ou mudanças de preços. diff --git a/docs/pt-BR/mcp/dsl-integration.mdx b/docs/pt-BR/mcp/dsl-integration.mdx index dd184f95a..3d22c1047 100644 --- a/docs/pt-BR/mcp/dsl-integration.mdx +++ b/docs/pt-BR/mcp/dsl-integration.mdx @@ -10,7 +10,9 @@ mode: "wide" A integração DSL (Domain Specific Language) MCP do CrewAI oferece a **forma mais simples** de conectar seus agentes aos servidores MCP (Model Context Protocol). Basta adicionar um campo `mcps` ao seu agente e o CrewAI cuida de toda a complexidade automaticamente. -Esta é a **abordagem recomendada** para a maioria dos casos de uso de MCP. Para cenários avançados que requerem gerenciamento manual de conexão, veja [MCPServerAdapter](/pt-BR/mcp/overview#advanced-mcpserveradapter). + Esta é a **abordagem recomendada** para a maioria dos casos de uso de MCP. + Para cenários avançados que requerem gerenciamento manual de conexão, veja + [MCPServerAdapter](/pt-BR/mcp/overview#advanced-mcpserveradapter). ## Uso Básico @@ -60,9 +62,9 @@ Use a sintaxe `#` para selecionar ferramentas específicas de um servidor: "https://mcp.exa.ai/mcp?api_key=sua_chave#web_search_exa" ``` -### Marketplace CrewAI AOP +### Marketplace CrewAI AMP -Acesse ferramentas do marketplace CrewAI AOP: +Acesse ferramentas do marketplace CrewAI AMP: ```python # Serviço completo com todas as ferramentas @@ -97,7 +99,7 @@ agente_multi_fonte = Agent( "https://mcp.exa.ai/mcp?api_key=sua_chave_exa&profile=pesquisa", "https://weather.api.com/mcp#get_current_conditions", - # Marketplace CrewAI AOP + # Marketplace CrewAI AMP "crewai-amp:financial-insights", "crewai-amp:academic-research#pubmed_search", "crewai-amp:market-intelligence#competitor_analysis" diff --git a/docs/pt-BR/mcp/overview.mdx b/docs/pt-BR/mcp/overview.mdx index 2d8d178e3..53aaaa32c 100644 --- a/docs/pt-BR/mcp/overview.mdx +++ b/docs/pt-BR/mcp/overview.mdx @@ -1,6 +1,6 @@ --- -title: 'Servidores MCP como Ferramentas no CrewAI' -description: 'Aprenda como integrar servidores MCP como ferramentas nos seus agentes CrewAI usando a biblioteca `crewai-tools`.' +title: "Servidores MCP como Ferramentas no CrewAI" +description: "Aprenda como integrar servidores MCP como ferramentas nos seus agentes CrewAI usando a biblioteca `crewai-tools`." icon: plug mode: "wide" --- @@ -25,7 +25,7 @@ agent = Agent( mcps=[ "https://mcp.exa.ai/mcp?api_key=sua_chave", # Servidor MCP externo "https://api.weather.com/mcp#get_forecast", # Ferramenta específica do servidor - "crewai-amp:financial-data", # Marketplace CrewAI AOP + "crewai-amp:financial-data", # Marketplace CrewAI AMP "crewai-amp:research-tools#pubmed_search" # Ferramenta AMP específica ] ) @@ -43,6 +43,7 @@ Atualmente, suportamos os seguintes mecanismos de transporte: - **Streamable HTTP**: para servidores remotos (comunicação flexível e potencialmente bidirecional via HTTP, geralmente utilizando SSE para streams do servidor para o cliente) ## Tutorial em Vídeo + Assista a este tutorial em vídeo para um guia abrangente sobre a integração do MCP com o CrewAI: - - Comece com o CrewAI AOP e faça o deploy da sua tripulação em ambiente de produção com apenas alguns cliques. + + Comece com o CrewAI AMP e faça o deploy da sua tripulação em ambiente de + produção com apenas alguns cliques. - Participe da nossa comunidade open source para discutir ideias, compartilhar seus projetos e conectar-se com outros desenvolvedores CrewAI. + Participe da nossa comunidade open source para discutir ideias, compartilhar + seus projetos e conectar-se com outros desenvolvedores CrewAI. diff --git a/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/README.md b/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/README.md index a331de33a..5e506b253 100644 --- a/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/README.md +++ b/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/README.md @@ -6,7 +6,7 @@ The GenerateCrewaiAutomationTool integrates with CrewAI Studio API to generate c ## Environment Variables -Set your CrewAI Personal Access Token (CrewAI AOP > Settings > Account > Personal Access Token): +Set your CrewAI Personal Access Token (CrewAI AMP > Settings > Account > Personal Access Token): ```bash export CREWAI_PERSONAL_ACCESS_TOKEN="your_personal_access_token_here" diff --git a/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/generate_crewai_automation_tool.py b/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/generate_crewai_automation_tool.py index 4f8b70547..4fd13b978 100644 --- a/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/generate_crewai_automation_tool.py +++ b/lib/crewai-tools/src/crewai_tools/tools/generate_crewai_automation_tool/generate_crewai_automation_tool.py @@ -11,7 +11,7 @@ class GenerateCrewaiAutomationToolSchema(BaseModel): ) organization_id: str | None = Field( default=None, - description="The identifier for the CrewAI AOP organization. If not specified, a default organization will be used.", + description="The identifier for the CrewAI AMP organization. If not specified, a default organization will be used.", ) @@ -25,11 +25,11 @@ class GenerateCrewaiAutomationTool(BaseTool): args_schema: type[BaseModel] = GenerateCrewaiAutomationToolSchema crewai_enterprise_url: str = Field( default_factory=lambda: os.getenv("CREWAI_PLUS_URL", "https://app.crewai.com"), - description="The base URL of CrewAI AOP. If not provided, it will be loaded from the environment variable CREWAI_PLUS_URL with default https://app.crewai.com.", + description="The base URL of CrewAI AMP. If not provided, it will be loaded from the environment variable CREWAI_PLUS_URL with default https://app.crewai.com.", ) personal_access_token: str | None = Field( default_factory=lambda: os.getenv("CREWAI_PERSONAL_ACCESS_TOKEN"), - description="The user's Personal Access Token to access CrewAI AOP API. If not provided, it will be loaded from the environment variable CREWAI_PERSONAL_ACCESS_TOKEN.", + description="The user's Personal Access Token to access CrewAI AMP API. If not provided, it will be loaded from the environment variable CREWAI_PERSONAL_ACCESS_TOKEN.", ) env_vars: list[EnvVar] = Field( default_factory=lambda: [ diff --git a/lib/crewai-tools/tool.specs.json b/lib/crewai-tools/tool.specs.json index ea2cef07a..ea38e6941 100644 --- a/lib/crewai-tools/tool.specs.json +++ b/lib/crewai-tools/tool.specs.json @@ -3195,13 +3195,13 @@ "env_vars": [ { "default": null, - "description": "Personal Access Token for CrewAI AOP API", + "description": "Personal Access Token for CrewAI AMP API", "name": "CREWAI_PERSONAL_ACCESS_TOKEN", "required": true }, { "default": null, - "description": "Base URL for CrewAI AOP API", + "description": "Base URL for CrewAI AMP API", "name": "CREWAI_PLUS_URL", "required": false } @@ -3247,7 +3247,7 @@ }, "properties": { "crewai_enterprise_url": { - "description": "The base URL of CrewAI AOP. If not provided, it will be loaded from the environment variable CREWAI_PLUS_URL with default https://app.crewai.com.", + "description": "The base URL of CrewAI AMP. If not provided, it will be loaded from the environment variable CREWAI_PLUS_URL with default https://app.crewai.com.", "title": "Crewai Enterprise Url", "type": "string" }, @@ -3260,7 +3260,7 @@ "type": "null" } ], - "description": "The user's Personal Access Token to access CrewAI AOP API. If not provided, it will be loaded from the environment variable CREWAI_PERSONAL_ACCESS_TOKEN.", + "description": "The user's Personal Access Token to access CrewAI AMP API. If not provided, it will be loaded from the environment variable CREWAI_PERSONAL_ACCESS_TOKEN.", "title": "Personal Access Token" } }, @@ -3281,7 +3281,7 @@ } ], "default": null, - "description": "The identifier for the CrewAI AOP organization. If not specified, a default organization will be used.", + "description": "The identifier for the CrewAI AMP organization. If not specified, a default organization will be used.", "title": "Organization Id" }, "prompt": { diff --git a/lib/crewai/README.md b/lib/crewai/README.md index 65723b39f..7faeae0fa 100644 --- a/lib/crewai/README.md +++ b/lib/crewai/README.md @@ -62,9 +62,9 @@ With over 100,000 developers certified through our community courses at [learn.crewai.com](https://learn.crewai.com), CrewAI is rapidly becoming the standard for enterprise-ready AI automation. -# CrewAI AOP Suite +# CrewAI AMP Suite -CrewAI AOP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation. +CrewAI AMP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation. You can try one part of the suite the [Crew Control Plane for free](https://app.crewai.com) @@ -76,9 +76,9 @@ You can try one part of the suite the [Crew Control Plane for free](https://app. - **Advanced Security**: Built-in robust security and compliance measures ensuring safe deployment and management. - **Actionable Insights**: Real-time analytics and reporting to optimize performance and decision-making. - **24/7 Support**: Dedicated enterprise support to ensure uninterrupted operation and quick resolution of issues. -- **On-premise and Cloud Deployment Options**: Deploy CrewAI AOP on-premise or in the cloud, depending on your security and compliance requirements. +- **On-premise and Cloud Deployment Options**: Deploy CrewAI AMP on-premise or in the cloud, depending on your security and compliance requirements. -CrewAI AOP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient, +CrewAI AMP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient, intelligent automations. ## Table of contents @@ -124,7 +124,8 @@ Setup and run your first CrewAI agents by following this tutorial. [![CrewAI Getting Started Tutorial](https://img.youtube.com/vi/-kSOTtYzgEw/hqdefault.jpg)](https://www.youtube.com/watch?v=-kSOTtYzgEw "CrewAI Getting Started Tutorial") ### - Learning Resources + +Learning Resources Learn CrewAI through our comprehensive courses: @@ -141,6 +142,7 @@ CrewAI offers two powerful, complementary approaches that work seamlessly togeth - Dynamic task delegation and collaboration - Specialized roles with defined goals and expertise - Flexible problem-solving approaches + 2. **Flows**: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide: - Fine-grained control over execution paths for real-world scenarios @@ -187,6 +189,7 @@ If you encounter issues during installation or usage, here are some common solut - Install tiktoken explicitly: `pip install 'crewai[embeddings]'` - If using embedchain or other tools: `pip install 'crewai[tools]'` + 2. **Failed building wheel for tiktoken** - Ensure Rust compiler is installed (see installation steps above) @@ -270,7 +273,7 @@ reporting_analyst: **tasks.yaml** -```yaml +````yaml # src/my_project/config/tasks.yaml research_task: description: > @@ -290,7 +293,7 @@ reporting_task: Formatted as markdown without '```' agent: reporting_analyst output_file: report.md -``` +```` **crew.py** @@ -556,7 +559,7 @@ Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM- - **LangGraph**: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework's tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems. -*P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb)).* +_P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb))._ - **Autogen**: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows. - **ChatDev**: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications. @@ -674,9 +677,9 @@ CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/b ### Enterprise Features -- [What additional features does CrewAI AOP offer?](#q-what-additional-features-does-crewai-enterprise-offer) -- [Is CrewAI AOP available for cloud and on-premise deployments?](#q-is-crewai-enterprise-available-for-cloud-and-on-premise-deployments) -- [Can I try CrewAI AOP for free?](#q-can-i-try-crewai-enterprise-for-free) +- [What additional features does CrewAI AMP offer?](#q-what-additional-features-does-crewai-enterprise-offer) +- [Is CrewAI AMP available for cloud and on-premise deployments?](#q-is-crewai-enterprise-available-for-cloud-and-on-premise-deployments) +- [Can I try CrewAI AMP for free?](#q-can-i-try-crewai-enterprise-for-free) ### Q: What exactly is CrewAI? @@ -732,17 +735,17 @@ A: Check out practical examples in the [CrewAI-examples repository](https://gith A: Contributions are warmly welcomed! Fork the repository, create your branch, implement your changes, and submit a pull request. See the Contribution section of the README for detailed guidelines. -### Q: What additional features does CrewAI AOP offer? +### Q: What additional features does CrewAI AMP offer? -A: CrewAI AOP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support. +A: CrewAI AMP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support. -### Q: Is CrewAI AOP available for cloud and on-premise deployments? +### Q: Is CrewAI AMP available for cloud and on-premise deployments? -A: Yes, CrewAI AOP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements. +A: Yes, CrewAI AMP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements. -### Q: Can I try CrewAI AOP for free? +### Q: Can I try CrewAI AMP for free? -A: Yes, you can explore part of the CrewAI AOP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free. +A: Yes, you can explore part of the CrewAI AMP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free. ### Q: Does CrewAI support fine-tuning or training custom models? @@ -762,7 +765,7 @@ A: CrewAI is highly scalable, supporting simple automations and large-scale ente ### Q: Does CrewAI offer debugging and monitoring tools? -A: Yes, CrewAI AOP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations. +A: Yes, CrewAI AMP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations. ### Q: What programming languages does CrewAI support? diff --git a/lib/crewai/src/crewai/agent/core.py b/lib/crewai/src/crewai/agent/core.py index 3658a330b..d06b3b6f7 100644 --- a/lib/crewai/src/crewai/agent/core.py +++ b/lib/crewai/src/crewai/agent/core.py @@ -1100,7 +1100,7 @@ class Agent(BaseAgent): raise RuntimeError(f"Failed to get native MCP tools: {e}") from e def _get_amp_mcp_tools(self, amp_ref: str) -> list[BaseTool]: - """Get tools from CrewAI AOP MCP marketplace.""" + """Get tools from CrewAI AMP MCP marketplace.""" # Parse: "crewai-amp:mcp-name" or "crewai-amp:mcp-name#tool_name" amp_part = amp_ref.replace("crewai-amp:", "") if "#" in amp_part: @@ -1355,7 +1355,7 @@ class Agent(BaseAgent): @staticmethod def _fetch_amp_mcp_servers(mcp_name: str) -> list[dict[str, Any]]: - """Fetch MCP server configurations from CrewAI AOP API.""" + """Fetch MCP server configurations from CrewAI AMP API.""" # TODO: Implement AMP API call to "integrations/mcps" endpoint # Should return list of server configs with URLs return [] diff --git a/lib/crewai/src/crewai/agents/agent_builder/base_agent.py b/lib/crewai/src/crewai/agents/agent_builder/base_agent.py index 93907c7c1..c58837cba 100644 --- a/lib/crewai/src/crewai/agents/agent_builder/base_agent.py +++ b/lib/crewai/src/crewai/agents/agent_builder/base_agent.py @@ -83,7 +83,7 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta): knowledge_sources: Knowledge sources for the agent. knowledge_storage: Custom knowledge storage for the agent. security_config: Security configuration for the agent, including fingerprinting. - apps: List of enterprise applications that the agent can access through CrewAI AOP Tools. + apps: List of enterprise applications that the agent can access through CrewAI AMP Tools. Methods: execute_task(task: Any, context: str | None = None, tools: list[BaseTool] | None = None) -> str: diff --git a/lib/crewai/src/crewai/cli/authentication/main.py b/lib/crewai/src/crewai/cli/authentication/main.py index 9f300fe54..996fd7c63 100644 --- a/lib/crewai/src/crewai/cli/authentication/main.py +++ b/lib/crewai/src/crewai/cli/authentication/main.py @@ -83,7 +83,7 @@ class AuthenticationCommand: def login(self) -> None: """Sign up to CrewAI+""" - console.print("Signing in to CrewAI AOP...\n", style="bold blue") + console.print("Signing in to CrewAI AMP...\n", style="bold blue") device_code_data = self._get_device_code() self._display_auth_instructions(device_code_data) @@ -145,7 +145,7 @@ class AuthenticationCommand: self._login_to_tool_repository() - console.print("\n[bold green]Welcome to CrewAI AOP![/bold green]\n") + console.print("\n[bold green]Welcome to CrewAI AMP![/bold green]\n") return if token_data["error"] not in ("authorization_pending", "slow_down"): diff --git a/lib/crewai/src/crewai/cli/cli.py b/lib/crewai/src/crewai/cli/cli.py index 2fb5d9887..a8f9571cc 100644 --- a/lib/crewai/src/crewai/cli/cli.py +++ b/lib/crewai/src/crewai/cli/cli.py @@ -271,7 +271,7 @@ def update(): @crewai.command() def login(): - """Sign Up/Login to CrewAI AOP.""" + """Sign Up/Login to CrewAI AMP.""" Settings().clear_user_settings() AuthenticationCommand().login() @@ -460,7 +460,7 @@ def enterprise(): @enterprise.command("configure") @click.argument("enterprise_url") def enterprise_configure(enterprise_url: str): - """Configure CrewAI AOP OAuth2 settings from the provided Enterprise URL.""" + """Configure CrewAI AMP OAuth2 settings from the provided Enterprise URL.""" enterprise_command = EnterpriseConfigureCommand() enterprise_command.configure(enterprise_url) diff --git a/lib/crewai/src/crewai/cli/config.py b/lib/crewai/src/crewai/cli/config.py index 9f2d203f9..d156d8488 100644 --- a/lib/crewai/src/crewai/cli/config.py +++ b/lib/crewai/src/crewai/cli/config.py @@ -103,7 +103,7 @@ HIDDEN_SETTINGS_KEYS = [ class Settings(BaseModel): enterprise_base_url: str | None = Field( default=DEFAULT_CLI_SETTINGS["enterprise_base_url"], - description="Base URL of the CrewAI AOP instance", + description="Base URL of the CrewAI AMP instance", ) tool_repository_username: str | None = Field( None, description="Username for interacting with the Tool Repository" diff --git a/lib/crewai/src/crewai/cli/enterprise/main.py b/lib/crewai/src/crewai/cli/enterprise/main.py index 99f0c15e6..2a73f1ae0 100644 --- a/lib/crewai/src/crewai/cli/enterprise/main.py +++ b/lib/crewai/src/crewai/cli/enterprise/main.py @@ -27,7 +27,7 @@ class EnterpriseConfigureCommand(BaseCommand): self._update_oauth_settings(enterprise_url, oauth_config) console.print( - f"✅ Successfully configured CrewAI AOP with OAuth2 settings from {enterprise_url}", + f"✅ Successfully configured CrewAI AMP with OAuth2 settings from {enterprise_url}", style="bold green", ) diff --git a/lib/crewai/tests/cli/authentication/test_auth_main.py b/lib/crewai/tests/cli/authentication/test_auth_main.py index 1825b50e1..5f7308e20 100644 --- a/lib/crewai/tests/cli/authentication/test_auth_main.py +++ b/lib/crewai/tests/cli/authentication/test_auth_main.py @@ -55,7 +55,7 @@ class TestAuthenticationCommand: self.auth_command.login() mock_console_print.assert_called_once_with( - "Signing in to CrewAI AOP...\n", style="bold blue" + "Signing in to CrewAI AMP...\n", style="bold blue" ) mock_get_device.assert_called_once() mock_display.assert_called_once_with( @@ -301,7 +301,7 @@ class TestAuthenticationCommand: expected_calls = [ call("\nWaiting for authentication... ", style="bold blue", end=""), call("Success!", style="bold green"), - call("\n[bold green]Welcome to CrewAI AOP![/bold green]\n"), + call("\n[bold green]Welcome to CrewAI AMP![/bold green]\n"), ] mock_console_print.assert_has_calls(expected_calls)