LangGraph vs. CrewAI: Choosing the Right Orchestrator

import os
from typing import TypedDict
from langgraph.graph import StateGraph, END
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# Set up environment variables
os.environ["LANGCHAIN_TRACING_V2"] = os.environ.get("LANGCHAIN_TRACING_V2", "false") # Optional for LangSmith

# Define the state for our graph
class GraphState(TypedDict):
    text: str
    sentiment: str
    entities: str
    summary: str

# Define the nodes (functions) for our graph
def analyze_sentiment(state: GraphState) -> GraphState:
    llm = ChatOpenAI(temperature=0)
    prompt = ChatPromptTemplate.from_messages([
        ("system", "Analyze the sentiment of the following text (positive, negative, neutral). Provide only the sentiment label."),
        ("user", "{text}")
    ])
    chain = prompt | llm | StrOutputParser()
    sentiment = chain.invoke({"text": state["text"]})
    return {"sentiment": sentiment}

def extract_entities(state: GraphState) -> GraphState:
    llm = ChatOpenAI(temperature=0)
    prompt = ChatPromptTemplate.from_messages([
        ("system", "Extract key entities (people, organizations, locations) from the following text. List them clearly."),
        ("user", "{text}")
    ])
    chain = prompt | llm | StrOutputParser()
    entities = chain.invoke({"text": state["text"]})
    return {"entities": entities}

def summarize_findings(state: GraphState) -> GraphState:
    llm = ChatOpenAI(temperature=0)
    prompt = ChatPromptTemplate.from_messages([
        ("system", "Synthesize the sentiment and key entities found in the text. Sentiment: {sentiment}, Entities: {entities}"),
        ("user", "Original text: {text}. Create a concise summary.")
    ])
    chain = prompt | llm | StrOutputParser()
    summary = chain.invoke({"sentiment": state["sentiment"], "entities": state["entities"], "text": state["text"]})
    return {"summary": summary}

# Build the LangGraph workflow
workflow = StateGraph(GraphState)

# Add nodes for each step
workflow.add_node("sentiment_analyzer", analyze_sentiment)
workflow.add_node("entity_extractor", extract_entities)
workflow.add_node("summarizer", summarize_findings)

# Set the entry point and define edges for sequential execution
workflow.set_entry_point("sentiment_analyzer")
workflow.add_edge("sentiment_analyzer", "entity_extractor")
workflow.add_edge("entity_extractor", "summarizer")
workflow.add_edge("summarizer", END)

# Compile the graph
app = workflow.compile()

# Example usage
sample_text = "The new product launch was a disaster. Many users reported critical bugs, but the support team handled it professionally."
initial_state = {"text": sample_text, "sentiment": "", "entities": "", "summary": ""}
final_state = app.invoke(initial_state)

print(f"Original Text: {final_state['text']}")
print(f"Sentiment: {final_state['sentiment']}")
print(f"Entities: {final_state['entities']}")
print(f"Summary: {final_state['summary']}")

import os
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# Set up environment variables

# Define agents
sentiment_analyst = Agent(
    role='Sentiment Analyst',
    goal='Identify the overall sentiment (positive, negative, neutral) of a given text.',
    backstory="""You are an expert sentiment analysis AI, skilled at discerning emotional tones
                and subjective opinions within text. You provide concise sentiment labels.""",
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0)
)

entity_extractor = Agent(
    role='Entity Extractor',
    goal='Extract key named entities (people, organizations, locations) from text.',
    backstory="""You are a meticulous entity extraction AI, capable of identifying and
                categorizing important nouns and proper nouns from any given document.""",
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0)
)

summarizer = Agent(
    role='Findings Summarizer',
    goal='Synthesize sentiment and extracted entities into a concise summary.',
    backstory="""You are a skilled summarization AI, able to combine disparate pieces
                of information into coherent and informative summaries.""",
    verbose=True,
    allow_delegation=False,
    llm=ChatOpenAI(model="gpt-4o", temperature=0)
)

# Define tasks
sample_text = "The new product launch was a disaster. Many users reported critical bugs, but the support team handled it professionally."

task_sentiment = Task(
    description=f"Analyze the sentiment of the following text: '{sample_text}'. Provide only the sentiment label (positive, negative, neutral).",
    agent=sentiment_analyst,
    expected_output="A single word: 'positive', 'negative', or 'neutral'."
)

task_entities = Task(
    description=f"Extract key entities (people, organizations, locations) from the text: '{sample_text}'. List them clearly.",
    agent=entity_extractor,
    expected_output="A list of extracted entities, categorized."
)

task_summarize = Task(
    description=f"""Synthesize the sentiment analysis and entity extraction results for the original text.
                 Combine the sentiment result from the 'Sentiment Analysis Task' and the entities from the 'Entity Extraction Task'
                 into a coherent summary. The original text was: '{sample_text}'""",
    agent=summarizer,
    context=[task_sentiment, task_entities], # Pass previous task outputs as context
    expected_output="A concise summary combining sentiment and entities."
)

# Form the crew
project_crew = Crew(
    agents=[sentiment_analyst, entity_extractor, summarizer],
    tasks=[task_sentiment, task_entities, task_summarize],
    verbose=True, # Set to True to enable verbose output
    process=Process.sequential # Ensures tasks run in order
)

# Kickoff the crew
result = project_crew.kickoff()
print("
########################")
print("## Here is the Report ##")
print("########################
")
print(result)