opencode-skills-collection 1.0.185 → 1.0.187

package/bundled-skills/crewai/SKILL.md

@@ -1,13 +1,19 @@
 ---
 name: crewai
-description: "You are an expert in designing collaborative AI agent teams with CrewAI. You think in terms of roles, responsibilities, and delegation. You design clear agent personas with specific expertise, create well-defined tasks with expected outputs, and orchestrate crews for optimal collaboration."
+description: Expert in CrewAI - the leading role-based multi-agent framework
+  used by 60% of Fortune 500 companies.
 risk: unknown
-source: "vibeship-spawner-skills (Apache 2.0)"
-date_added: "2026-02-27"
+source: vibeship-spawner-skills (Apache 2.0)
+date_added: 2026-02-27
 ---
 
 # CrewAI
 
+Expert in CrewAI - the leading role-based multi-agent framework used by 60% of Fortune 500
+companies. Covers agent design with roles and goals, task definition, crew orchestration,
+process types (sequential, hierarchical, parallel), memory systems, and flows for complex
+workflows. Essential for building collaborative AI agent teams.
+
 **Role**: CrewAI Multi-Agent Architect
 
 You are an expert in designing collaborative AI agent teams with CrewAI. You think
@@ -16,6 +22,15 @@ with specific expertise, create well-defined tasks with expected outputs, and
 orchestrate crews for optimal collaboration. You know when to use sequential vs
 hierarchical processes.
 
+### Expertise
+
+- Agent persona design
+- Task decomposition
+- Crew orchestration
+- Process selection
+- Memory configuration
+- Flow design
+
 ## Capabilities
 
 - Agent definitions (role, goal, backstory)
@@ -26,11 +41,39 @@ hierarchical processes.
 - Tool integration
 - Flows for complex workflows
 
-## Requirements
+## Prerequisites
+
+- 0: Python proficiency
+- 1: Multi-agent concepts
+- 2: Understanding of delegation
+- Required skills: Python 3.10+, crewai package, LLM API access
+
+## Scope
+
+- 0: Python-only
+- 1: Best for structured workflows
+- 2: Can be verbose for simple cases
+- 3: Flows are newer feature
+
+## Ecosystem
+
+### Primary
+
+- CrewAI framework
+- CrewAI Tools
+
+### Common_integrations
 
-- Python 3.10+
-- crewai package
-- LLM API access
+- OpenAI / Anthropic / Ollama
+- SerperDev (search)
+- FileReadTool, DirectoryReadTool
+- Custom tools
+
+### Platforms
+
+- Python applications
+- FastAPI backends
+- Enterprise deployments
 
 ## Patterns
 
@@ -40,7 +83,6 @@ Define agents and tasks in YAML (recommended)
 
 **When to use**: Any CrewAI project
 
-```python
 # config/agents.yaml
 researcher:
   role: "Senior Research Analyst"
@@ -119,8 +161,20 @@ class ContentCrew:
 
     @task
     def writing_task(self) -> Task:
-        return Task(config
-```
+        return Task(config=self.tasks_config['writing_task'])
+
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True
+        )
+
+# main.py
+crew = ContentCrew()
+result = crew.crew().kickoff(inputs={"topic": "AI Agents in 2025"})
 
 ### Hierarchical Process
 
@@ -128,7 +182,6 @@ Manager agent delegates to workers
 
 **When to use**: Complex tasks needing coordination
 
-```python
 from crewai import Crew, Process
 
 # Define specialized agents
@@ -165,7 +218,6 @@ crew = Crew(
 # - How to combine results
 
 result = crew.kickoff()
-```
 
 ### Planning Feature
 
@@ -173,7 +225,6 @@ Generate execution plan before running
 
 **When to use**: Complex workflows needing structure
 
-```python
 from crewai import Crew, Process
 
 # Enable planning
@@ -195,54 +246,209 @@ result = crew.kickoff()
 
 # Access the plan
 print(crew.plan)
-```
 
-## Anti-Patterns
+### Memory Configuration
 
-### ❌ Vague Agent Roles
+Enable agent memory for context
 
-**Why bad**: Agent doesn't know its specialty.
-Overlapping responsibilities.
-Poor task delegation.
+**When to use**: Multi-turn or complex workflows
 
-**Instead**: Be specific:
-- "Senior React Developer" not "Developer"
-- "Financial Analyst specializing in crypto" not "Analyst"
-Include specific skills in backstory.
+from crewai import Crew
 
-### ❌ Missing Expected Outputs
+# Memory types:
+# - Short-term: Within task execution
+# - Long-term: Across executions
+# - Entity: About specific entities
 
-**Why bad**: Agent doesn't know done criteria.
-Inconsistent outputs.
-Hard to chain tasks.
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,  # Enable all memory types
+    verbose=True
+)
 
-**Instead**: Always specify expected_output:
-expected_output: |
-  A JSON object with:
-  - summary: string (100 words max)
-  - key_points: list of strings
-  - confidence: float 0-1
+# Custom memory config
+from crewai.memory import LongTermMemory, ShortTermMemory
 
-### ❌ Too Many Agents
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    long_term_memory=LongTermMemory(
+        storage=CustomStorage()  # Custom backend
+    ),
+    short_term_memory=ShortTermMemory(
+        storage=CustomStorage()
+    ),
+    embedder={
+        "provider": "openai",
+        "config": {"model": "text-embedding-3-small"}
+    }
+)
+
+# Memory helps agents:
+# - Remember previous interactions
+# - Build on past work
+# - Maintain consistency
+
+### Flows for Complex Workflows
+
+Event-driven orchestration with state
+
+**When to use**: Complex, multi-stage workflows
+
+from crewai.flow.flow import Flow, listen, start, and_, or_, router
+
+class ContentFlow(Flow):
+    # State persists across steps
+    model_config = {"extra": "allow"}
+
+    @start()
+    def gather_requirements(self):
+        """First step - gather inputs."""
+        self.topic = self.inputs.get("topic", "AI")
+        self.style = self.inputs.get("style", "professional")
+        return {"topic": self.topic}
+
+    @listen(gather_requirements)
+    def research(self, requirements):
+        """Research after requirements gathered."""
+        research_crew = ResearchCrew()
+        result = research_crew.crew().kickoff(
+            inputs={"topic": requirements["topic"]}
+        )
+        self.research = result.raw
+        return result
+
+    @listen(research)
+    def write_content(self, research_result):
+        """Write after research complete."""
+        writing_crew = WritingCrew()
+        result = writing_crew.crew().kickoff(
+            inputs={
+                "research": self.research,
+                "style": self.style
+            }
+        )
+        return result
+
+    @router(write_content)
+    def quality_check(self, content):
+        """Route based on quality."""
+        if self.needs_revision(content):
+            return "revise"
+        return "publish"
+
+    @listen("revise")
+    def revise_content(self):
+        """Revision flow."""
+        # Re-run writing with feedback
+        pass
+
+    @listen("publish")
+    def publish_content(self):
+        """Final publishing."""
+        return {"status": "published", "content": self.content}
+
+# Run flow
+flow = ContentFlow()
+result = flow.kickoff(inputs={"topic": "AI Agents"})
+
+### Custom Tools
+
+Create tools for agents
+
+**When to use**: Agents need external capabilities
+
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+# Method 1: Class-based tool
+class SearchInput(BaseModel):
+    query: str = Field(..., description="Search query")
+
+class WebSearchTool(BaseTool):
+    name: str = "web_search"
+    description: str = "Search the web for information"
+    args_schema: type[BaseModel] = SearchInput
+
+    def _run(self, query: str) -> str:
+        # Implementation
+        results = search_api.search(query)
+        return format_results(results)
+
+# Method 2: Function decorator
+from crewai import tool
+
+@tool("Database Query")
+def query_database(sql: str) -> str:
+    """Execute SQL query and return results."""
+    return db.execute(sql)
+
+# Assign tools to agents
+researcher = Agent(
+    role="Researcher",
+    goal="Find information",
+    backstory="...",
+    tools=[WebSearchTool(), query_database]
+)
+
+## Collaboration
+
+### Delegation Triggers
+
+- langgraph|state machine|graph -> langgraph (Need explicit state management)
+- observability|tracing -> langfuse (Need LLM observability)
+- structured output|json schema -> structured-output (Need structured responses)
+
+### Research and Writing Crew
+
+Skills: crewai, structured-output
+
+Workflow:
+
+```
+1. Define researcher and writer agents
+2. Create research → analysis → writing pipeline
+3. Use structured output for research format
+4. Chain tasks with context
+```
+
+### Observable Agent Team
 
-**Why bad**: Coordination overhead.
-Inconsistent communication.
-Slower execution.
+Skills: crewai, langfuse
 
-**Instead**: 3-5 agents with clear roles.
-One agent can handle multiple related tasks.
-Use tools instead of agents for simple actions.
+Workflow:
+
+```
+1. Build crew with agents and tasks
+2. Add Langfuse callback handler
+3. Monitor agent interactions
+4. Evaluate output quality
+```
 
-## Limitations
+### Complex Workflow with Flows
 
-- Python-only
-- Best for structured workflows
-- Can be verbose for simple cases
-- Flows are newer feature
+Skills: crewai, langgraph
+
+Workflow:
+
+```
+1. Design workflow with CrewAI Flows
+2. Use LangGraph patterns for state
+3. Combine crews in flow steps
+4. Handle branching and routing
+```
 
 ## Related Skills
 
 Works well with: `langgraph`, `autonomous-agents`, `langfuse`, `structured-output`
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+
+- User mentions or implies: crewai
+- User mentions or implies: multi-agent team
+- User mentions or implies: agent roles
+- User mentions or implies: crew of agents
+- User mentions or implies: role-based agents
+- User mentions or implies: collaborative agents