CrewAI如何使AI代理成为协作团队成员

from crewai import Agent
from crewai_tools import SerperDevTool  
 
researcher = Agent(  
    role="Market Research Analyst",  
    goal="Identify emerging market trends",  
    backstory="An experienced analyst with a focus on technology and startups.",  
    llm="gpt-4o-mini",  # Specifies the language model  
    tools=[SerperDevTool()],  # Integrates a web search tool  
    memory=True,  # Retains interaction history  
    allow_delegation=False,  # Restricts task delegation  
    verbose=True  # Enables detailed logs  
) 

from crewai import Agent, LLM
 
custom_llm = LLM(
    model="gpt-4o-mini",
    temperature=0.7,
    max_tokens=4000
)
 
researcher = Agent(
    role="AI Researcher",
    goal="Analyze AI adoption trends",
    backstory="A data-driven analyst specializing in AI trends",
    llm=custom_llm
)

from crewai import Agent, Task, Crew, tools
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
 
# Initialize vector database
vectorstore = Chroma(
    embedding_function=OpenAIEmbeddings(),
    persist_directory="./research_db"
)
 
# Create a custom tool for vector search
@tools.tool('Vector Search')
def vector_search(query: str) -> str:
    """Search vector database for relevant context"""
    results = vectorstore.similarity_search(query)
    return str(results)
 
# Create a research agent with vector database access
researcher = Agent(
    role='Research Specialist',
    goal='Retrieve precise information from vector database',
    backstory='I am an expert at retrieving and analyzing information from databases',
    tools=[vector_search],
    verbose=True
)
 
# Define task utilizing vector database
research_task = Task(
    description='Conduct targeted research using vector database',
    agent=researcher
)
 
# Create crew
crew = Crew(
    agents=[researcher],
    tasks=[research_task],
    verbose=True
)
 
# Execute workflow
result = crew.kickoff()

from crewai import Agent, Task, Crew
from langchain_openai import ChatOpenAI
 
researcher = Agent(
    role='Market Research Analyst',
    goal='Discover emerging market trends',
    backstory='Expert in identifying innovative business opportunities',
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model_name="gpt-4")
)
 
writer = Agent(
    role='Content Strategist',
    goal='Create compelling marketing narratives',
    backstory='Skilled at transforming research into engaging content',
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model_name="gpt-4")
)
 
research_task = Task(
    description='Analyze current market trends',
    agent=researcher,
    expected_output="A detailed analysis of current market trends"
)
 
writing_task = Task(
    description='Develop marketing strategy based on research',
    agent=writer,
    context=research_task.output,
    expected_output="A comprehensive marketing strategy document"
)
 
market_crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True 
)
 
result = market_crew.kickoff()
print(result)

from crewai.flow.flow import Flow, listen, start  
from litellm import completion  
 
class ExampleFlow(Flow):  
    model = "gpt-4o-mini"  
 
    @start()  
    def generate_city(self):  
        response = completion(  
            model=self.model,  
            messages=[  
                {"role": "user", "content": "Return the name of a random city in the world."},  
            ],  
        )  
        random_city = response["choices"][0]["message"]["content"]  
        return random_city  
 
    @listen(generate_city)  
    def generate_fun_fact(self, random_city):  
        response = completion(  
            model=self.model,  
            messages=[  
                {"role": "user", "content": f"Tell me a fun fact about {random_city}"},  
            ],  
        )  
        fun_fact = response["choices"][0]["message"]["content"]  
        return fun_fact  
 
flow = ExampleFlow()  
result = flow.kickoff()  
print(f"Generated fun fact: {result}")  

from crewai import Agent, Task, Crew  
from crewai_tools import PDFSearchTool  
 
# Define RAG tool  
rag_tool = PDFSearchTool(  
    pdf='research_paper.pdf'  
)  
 
# Define agent with RAG capabilities  
researcher = Agent(  
    role='Research Analyst',  
    goal='Extract key insights from research documents',  
    backstory='Expert at analyzing complex academic papers',  
    tools=[rag_tool]  
)  
 
# Define task for RAG  
research_task = Task(  
    description='Analyze the research paper and summarize key findings',  
    agent=researcher,  
    tools=[rag_tool],  
    expected_output='A detailed summary of the key findings from the research paper'  
)  
 
# Create Crew to coordinate workflow  
research_crew = Crew(  
    agents=[researcher],  
    tasks=[research_task],  
    process='sequential'  
)  
 
# Execute RAG workflow  
result = research_crew.kickoff()  
print(result)  

from crewai import Agent, Task, Crew  
from crewai_tools import PDFSearchTool  
 
def create_research_crew(doc):  
    tool = PDFSearchTool(pdf=doc)  
    agent = Agent(
        role="Research Analyst",
        tools=[tool],
        goal="Summarize document insights",
        backstory="I am an expert research analyst who specializes in extracting and summarizing key insights from documents."
    )  
    task = Task(
        description="Analyze and summarize content", 
        agent=agent,
        expected_output="A comprehensive summary of the key insights from the document"
    )  
    return Crew(agents=[agent], tasks=[task], process="sequential")  
 
# Execute for multiple documents  
for pdf in ["doc1.pdf", "doc2.pdf"]:  
    crew = create_research_crew(pdf)  
    print(crew.kickoff())