LangGraph Tutorial: A Step-by-Step Information to Making a Textual content Evaluation Pipeline

# Set up required packages
!pip set up langgraph langchain langchain-openai python-dotenv

import os
from dotenv import load_dotenv

# Load atmosphere variables from .env file (create this together with your API key)
load_dotenv()

# Set OpenAI API key
os.environ["OPENAI_API_KEY"] = os.getenv('OPENAI_API_KEY')

from langchain_openai import ChatOpenAI

# Initialize the ChatOpenAI occasion
llm = ChatOpenAI(mannequin="gpt-4o-mini")

# Take a look at the setup
response = llm.invoke("Hi there! Are you working?")
print(response.content material)

import os
from typing import TypedDict, Record, Annotated
from langgraph.graph import StateGraph, END
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
from langchain_core.runnables.graph import MermaidDrawMethod
from IPython.show import show, Picture

class State(TypedDict):
    textual content: str
    classification: str
    entities: Record[str]
    abstract: str

# Initialize our language mannequin with temperature=0 for extra deterministic outputs
llm = ChatOpenAI(mannequin="gpt-4o-mini", temperature=0)

def classification_node(state: State):
    '''Classify the textual content into one of many classes: Information, Weblog, Analysis, or Different'''
    immediate = PromptTemplate(
        input_variables=["text"],
        template="Classify the next textual content into one of many classes: Information, Weblog, Analysis, or Different.nnText:{textual content}nnCategory:"
    )
    message = HumanMessage(content material=immediate.format(textual content=state["text"]))
    classification = llm.invoke([message]).content material.strip()
    return {"classification": classification}

def entity_extraction_node(state: State):
    '''Extract all of the entities (Particular person, Group, Location) from the textual content'''
    immediate = PromptTemplate(
        input_variables=["text"],
        template="Extract all of the entities (Particular person, Group, Location) from the next textual content. Present the consequence as a comma-separated checklist.nnText:{textual content}nnEntities:"
    )
    message = HumanMessage(content material=immediate.format(textual content=state["text"]))
    entities = llm.invoke([message]).content material.strip().break up(", ")
    return {"entities": entities}

def summarization_node(state: State):
    '''Summarize the textual content in a single brief sentence'''
    immediate = PromptTemplate(
        input_variables=["text"],
        template="Summarize the next textual content in a single brief sentence.nnText:{textual content}nnSummary:"
    )
    message = HumanMessage(content material=immediate.format(textual content=state["text"]))
    abstract = llm.invoke([message]).content material.strip()
    return {"abstract": abstract}

# Create our StateGraph
workflow = StateGraph(State)

# Add nodes to the graph
workflow.add_node("classification_node", classification_node)
workflow.add_node("entity_extraction", entity_extraction_node)
workflow.add_node("summarization", summarization_node)

# Add edges to the graph
workflow.set_entry_point("classification_node")  # Set the entry level of the graph
workflow.add_edge("classification_node", "entity_extraction")
workflow.add_edge("entity_extraction", "summarization")
workflow.add_edge("summarization", END)

# Compile the graph
app = workflow.compile()

sample_text = """ OpenAI has introduced the GPT-4 mannequin, which is a big multimodal mannequin that reveals human-level efficiency on varied skilled benchmarks. It's developed to enhance the alignment and security of AI programs. Moreover, the mannequin is designed to be extra environment friendly and scalable than its predecessor, GPT-3. The GPT-4 mannequin is anticipated to be launched within the coming months and shall be accessible to the general public for analysis and growth functions. """ 
state_input = {"textual content": sample_text} 
consequence = app.invoke(state_input) 
print("Classification:", consequence["classification"]) 
print("nEntities:", consequence["entities"]) 
print("nSummary:", consequence["summary"])
Classification: Information Entities: ['OpenAI', 'GPT-4', 'GPT-3'] Abstract: OpenAI's upcoming GPT-4 mannequin is a multimodal AI that goals for human-level efficiency and improved security, effectivity, and scalability in comparison with GPT-3.

# Change this with your personal textual content to investigate your_text = """ The latest developments in quantum computing have opened new prospects for cryptography and knowledge safety. Researchers at MIT and Google have demonstrated quantum algorithms that might probably break present encryption strategies. Nevertheless, they're additionally growing new quantum-resistant encryption strategies to guard knowledge sooner or later. """ 

# Course of the textual content by means of our pipeline your_result = app.invoke({"textual content": your_text}) print("Classification:", your_result["classification"]) 

print("nEntities:", your_result["entities"]) 
print("nSummary:", your_result["summary"])

Classification: Analysis Entities: ['MIT', 'Google'] Abstract: Latest developments in quantum computing could threaten present encryption strategies whereas additionally prompting the event of recent quantum-resistant strategies.

# First, let's replace our State to incorporate sentiment
class EnhancedState(TypedDict):
    textual content: str
    classification: str
    entities: Record[str]
    abstract: str
    sentiment: str

# Create our sentiment evaluation node
def sentiment_node(state: EnhancedState):
    '''Analyze the sentiment of the textual content: Optimistic, Adverse, or Impartial'''
    immediate = PromptTemplate(
        input_variables=["text"],
        template="Analyze the sentiment of the next textual content. Is it Optimistic, Adverse, or Impartial?nnText:{textual content}nnSentiment:"
    )
    message = HumanMessage(content material=immediate.format(textual content=state["text"]))
    sentiment = llm.invoke([message]).content material.strip()
    return {"sentiment": sentiment}

# Create a brand new workflow with the improved state
enhanced_workflow = StateGraph(EnhancedState)

# Add the present nodes
enhanced_workflow.add_node("classification_node", classification_node)
enhanced_workflow.add_node("entity_extraction", entity_extraction_node)
enhanced_workflow.add_node("summarization", summarization_node)

# Add our new sentiment node
enhanced_workflow.add_node("sentiment_analysis", sentiment_node)

# Create a extra complicated workflow with branches
enhanced_workflow.set_entry_point("classification_node")
enhanced_workflow.add_edge("classification_node", "entity_extraction")
enhanced_workflow.add_edge("entity_extraction", "summarization")
enhanced_workflow.add_edge("summarization", "sentiment_analysis")
enhanced_workflow.add_edge("sentiment_analysis", END)

# Compile the improved graph
enhanced_app = enhanced_workflow.compile()

# Attempt the improved pipeline with the identical textual content
enhanced_result = enhanced_app.invoke({"textual content": sample_text})

print("Classification:", enhanced_result["classification"])
print("nEntities:", enhanced_result["entities"])
print("nSummary:", enhanced_result["summary"])
print("nSentiment:", enhanced_result["sentiment"])

# Route after classification
def route_after_classification(state: EnhancedState) -> str:
    class = state["classification"].decrease() # returns: "information", "weblog", "analysis", "different"
    return class in ["news", "research"]

from langgraph.graph import StateGraph, END

conditional_workflow = StateGraph(EnhancedState)

# Add nodes
conditional_workflow.add_node("classification_node", classification_node)
conditional_workflow.add_node("entity_extraction", entity_extraction_node)
conditional_workflow.add_node("summarization", summarization_node)
conditional_workflow.add_node("sentiment_analysis", sentiment_node)

# Set entry level
conditional_workflow.set_entry_point("classification_node")

# Add conditional edge
conditional_workflow.add_conditional_edges("classification_node", route_after_classification, path_map={
    True: "entity_extraction",
    False: "summarization"
})

# Add remaining static edges
conditional_workflow.add_edge("entity_extraction", "summarization")
conditional_workflow.add_edge("summarization", "sentiment_analysis")
conditional_workflow.add_edge("sentiment_analysis", END)

# Compile
conditional_app = conditional_workflow.compile()

test_text = """
OpenAI launched the GPT-4 mannequin with enhanced efficiency on tutorial {and professional} duties. It is seen as a serious breakthrough in alignment and reasoning capabilities.
"""

consequence = conditional_app.invoke({"textual content": test_text})

print("Classification:", consequence["classification"])
print("Entities:", consequence.get("entities", "Skipped"))
print("Abstract:", consequence["summary"])
print("Sentiment:", consequence["sentiment"])

blog_text = """
This is what I realized from every week of meditating in silence. No telephones, no speaking—simply me, my breath, and a few deep realizations.
"""

consequence = conditional_app.invoke({"textual content": blog_text})

print("Classification:", consequence["classification"])
print("Entities:", consequence.get("entities", "Skipped (not relevant)"))
print("Abstract:", consequence["summary"])
print("Sentiment:", consequence["sentiment"])