În primul rând de instalat uneltele necesare 

Nota Bene: Se poate instala si folosi Jupyter Notebook sau VS Code cu extensia Jupyter. Respectiv se poate utiliza direct codul in Cmd Prompt sau in Terminal(Powershell), dar va fi dificil de a salva sau de a previzualiza. De instalat prima data python/pip. Ambele se vor instala după ce Python va fi instalat. Pentru Windows OS se poate nota “python” simplu in cmd prompt sau in terminal(powershell) pentru a apărea fereastra Microsoft Store cu versiunea de Python(ex. Python 3.13 interpreter and runtime).

# Instalați pachetele necesare

!pip install -q langgraph langchain-core langchain-openai python-dotenv ipyth

Importați bibliotecile/librăriile necesare

from typing import Dict, TypedDict
from langgraph.graph import StateGraph, END
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

from IPython.display import display, Image
from langchain_core.runnables.graph import MermaidDrawMethod
from dotenv import load_dotenv
import os

# Încărcați variabilele de mediu și setați cheia API OpenAI
load_dotenv()
os.environ[“OPENAI_API_KEY”] = os.getenv(‘OPENAI_API_KEY’)

Nota bene: De inclus in loc de “OPENAI_API_KEY” cheia secretă de aici https://platform.openai.com/api-keys

Definiți structura de tip State

Definim o clasă State pentru a stoca interogarea, categoria, sentimentul și răspunsul pentru fiecare interacțiune cu clientul:

class State(TypedDict):
query: str
category: str
sentiment: str
response: str

Definiți funcțiile nodului

Aceste funcții reprezintă diferitele etape ale procesării unei solicitări ale clientului:

def categorize(state: State) -> State:
“””Categorize the customer query into Technical, Billing, or General.”””
prompt = ChatPromptTemplate.from_template(
“Categorize the following customer query into one of these categories: ”
“Technical, Billing, General. Query: {query}”
)
chain = prompt | ChatOpenAI(temperature=0)
category = chain.invoke({“query”: state[“query”]}).content
return {“category”: category}

def analyze_sentiment(state: State) -> State:
“””Analyze the sentiment of the customer query as Positive, Neutral, or Negative.”””
prompt = ChatPromptTemplate.from_template(
“Analyze the sentiment of the following customer query. ”
“Respond with either ‘Positive’, ‘Neutral’, or ‘Negative’. Query: {query}”
)
chain = prompt | ChatOpenAI(temperature=0)
sentiment = chain.invoke({“query”: state[“query”]}).content
return {“sentiment”: sentiment}

def handle_technical(state: State) -> State:
“””Provide a technical support response to the query.”””
prompt = ChatPromptTemplate.from_template(
“Provide a technical support response to the following query: {query}”
)
chain = prompt | ChatOpenAI(temperature=0)
response = chain.invoke({“query”: state[“query”]}).content
return {“response”: response}

def handle_billing(state: State) -> State:
“””Provide a billing support response to the query.”””
prompt = ChatPromptTemplate.from_template(
“Provide a billing support response to the following query: {query}”
)
chain = prompt | ChatOpenAI(temperature=0)
response = chain.invoke({“query”: state[“query”]}).content
return {“response”: response}

def handle_general(state: State) -> State:
“””Provide a general support response to the query.”””
prompt = ChatPromptTemplate.from_template(
“Provide a general support response to the following query: {query}”
)
chain = prompt | ChatOpenAI(temperature=0)
response = chain.invoke({“query”: state[“query”]}).content
return {“response”: response}

def escalate(state: State) -> State:
“””Escalate the query to a human agent due to negative sentiment.”””
return {“response”: “This query has been escalated to a human agent due to its negative sentiment.”}

def route_query(state: State) -> str:
“””Route the query based on its sentiment and category.”””
if state[“sentiment”] == “Negative”:
return “escalate”
elif state[“category”] == “Technical”:
return “handle_technical”
elif state[“category”] == “Billing”:
return “handle_billing”
else:
return “handle_general”

Creați și configurați graficul

În această etapă configurăm LangGraph, definind noduri și muchii pentru a crea fluxul de lucru al serviciului nostru de asistență pentru clienți:

# Creați graficul
workflow = StateGraph(State)

# Adăugați noduri/nodes
workflow.add_node(“categorize”, categorize)
workflow.add_node(“analyze_sentiment”, analyze_sentiment)
workflow.add_node(“handle_technical”, handle_technical)
workflow.add_node(“handle_billing”, handle_billing)
workflow.add_node(“handle_general”, handle_general)
workflow.add_node(“escalate”, escalate)

# Adăugați margini
workflow.add_edge(“categorize”, “analyze_sentiment”)
workflow.add_conditional_edges(
“analyze_sentiment”,
route_query,
{
“handle_technical”: “handle_technical”,
“handle_billing”: “handle_billing”,
“handle_general”: “handle_general”,
“escalate”: “escalate”
}
)
workflow.add_edge(“handle_technical”, END)
workflow.add_edge(“handle_billing”, END)
workflow.add_edge(“handle_general”, END)
workflow.add_edge(“escalate”, END)

# Setați punctul de intrare
workflow.set_entry_point(“categorize”)

# Compilați graficul
app = workflow.compile()

Vizualizați graficul

Această celulă generează și afișează o reprezentare vizuală a fluxului nostru de lucru LangGraph:

display(
Image(
app.get_graph().draw_mermaid_png(
draw_method=MermaidDrawMethod.API,
)
)
)

Funcția de asistență pentru clienți

Această funcție procesează o solicitare a clientului prin fluxul de lucru LangGraph:

def run_customer_support(query: str) -> Dict[str, str]:
“””Process a customer query through the LangGraph workflow.

Args:
query (str): The customer’s query

Returns:
Dict[str, str]: A dictionary containing the query’s category, sentiment, and response
“””
results = app.invoke({“query”: query})
return {
“category”: results[“category”],
“sentiment”: results[“sentiment”],
“response”: results[“response”]
}

De testat în terminal/CLI sau în JupyterNotepad agentul de asistență pentru clienți

# escalate

query = “Conexiunea mea la internet se întrerupe mereu. Mă puteți ajuta?”
result = run_customer_support(query)
print(f”Query: {query}”)
print(f”Category: {result[‘category’]}”)
print(f”Sentiment: {result[‘sentiment’]}”)
print(f”Response: {result[‘response’]}”)
print(“\n”)

# handle_technical

query = “Am nevoie de ajutor pentru a vorbi cu chatGPT”
result = run_customer_support(query)
print(f”Query: {query}”)
print(f”Category: {result[‘category’]}”)
print(f”Sentiment: {result[‘sentiment’]}”)
print(f”Response: {result[‘response’]}”)
print(“\n”)

# handle_billing

query = “Unde pot găsi chitanța?”
result = run_customer_support(query)
print(f”Query: {query}”)
print(f”Category: {result[‘category’]}”)
print(f”Sentiment: {result[‘sentiment’]}”)
print(f”Response: {result[‘response’]}”)
print(“\n”)

# handle_general

query = “Care este programul dvs. de lucru?”
result = run_customer_support(query)
print(f”Query: {query}”)
print(f”Category: {result[‘category’]}”)
print(f”Sentiment: {result[‘sentiment’]}”)
print(f”Response: {result[‘response’]}”)

Răspunsurile la test ar trebui să fie similare cu acestea(Răspunsurile trebuie verificate):

Întrebare: Conexiunea mea la internet se întrerupe în mod constant. Mă puteți ajuta?
Categorie: Tehnică
Sentiment: Negativ
Răspuns: Această întrebare a fost redirecționată către un agent uman din cauza sentimentului negativ pe care îl transmite.

Întrebare: Am nevoie de ajutor pentru a comunica cu chatGPT.
Categorie: Tehnică
Sentiment: Neutru
Răspuns: Bună ziua,

Vă mulțumim că ați contactat serviciul de asistență tehnică. Pentru a comunica cu ChatGPT, puteți pur și simplu să tastați mesajul sau întrebarea dvs. în caseta de chat furnizată pe platformă. ChatGPT este conceput pentru a răspunde la intrările de text și pentru a purta conversații pe baza contextului furnizat.

Dacă întâmpinați dificultăți în comunicarea cu ChatGPT, vă rugăm să ne furnizați mai multe detalii despre problema cu care vă confruntați, astfel încât să vă putem ajuta în continuare. Acestea pot include mesaje de eroare, întrebări specifice sau orice alte informații relevante care ne pot ajuta să rezolvăm problema.

Suntem aici pentru a vă ajuta și vom face tot posibilul pentru a vă asista în comunicarea eficientă cu ChatGPT. Vă mulțumim pentru răbdare și cooperare.

Cu respect,
[Numele dvs.]
Echipa de asistență tehnică

Întrebare: Unde pot găsi chitanța?
Categorie: Facturare
Sentiment: Neutru
Răspuns: Vă mulțumim că ne-ați contactat. Pentru a găsi chitanța, vă rugăm să verificați căsuța de e-mail pentru a găsi un e-mail de confirmare trimis în momentul achiziției. De asemenea, vă puteți conecta la contul dvs. de pe site-ul nostru web și puteți naviga la secțiunea „Istoric comenzi” pentru a vizualiza și descărca chitanța. Dacă nu puteți găsi chitanța, vă rugăm să ne furnizați numărul comenzii sau orice alte informații relevante.