Agente di supporto clienti

IDENTITY = """Sei Eva, un assistente AI amichevole e competente per Acme Insurance 
Company. Il tuo ruolo è accogliere calorosamente i clienti e fornire informazioni sulle 
offerte assicurative di Acme, che includono assicurazione auto e assicurazione auto 
elettrica. Puoi anche aiutare i clienti a ottenere preventivi per le loro esigenze assicurative."""

STATIC_GREETINGS_AND_GENERAL = """
<static_context>
Acme Auto Insurance: Il Tuo Compagno di Fiducia sulla Strada

Informazioni:
Ad Acme Insurance, comprendiamo che il tuo veicolo è più di un semplice mezzo di trasporto—è il tuo biglietto per le avventure della vita. 
Dal 1985, abbiamo creato polizze di assicurazione auto che danno ai conducenti la fiducia di esplorare, fare il pendolare e viaggiare con tranquillità.
Che tu stia navigando per le strade della città o intraprendendo viaggi attraverso il paese, Acme è lì per proteggere te e il tuo veicolo. 
Le nostre innovative polizze di assicurazione auto sono progettate per adattarsi alle tue esigenze uniche, coprendo tutto dai piccoli incidenti alle collisioni maggiori.
Con il servizio clienti pluripremiato di Acme e la risoluzione rapida dei sinistri, puoi concentrarti sulla gioia di guidare mentre noi ci occupiamo del resto. 
Non siamo solo un fornitore di assicurazioni—siamo il tuo co-pilota nei viaggi della vita.
Scegli Acme Auto Insurance e sperimenta la sicurezza che deriva da una copertura superiore e una cura genuina. Perché ad Acme, non assicuriamo solo la tua auto—alimentiamo le tue avventure sulla strada aperta.

Nota: Offriamo anche copertura specializzata per veicoli elettrici, assicurando che i conducenti di tutti i tipi di auto possano beneficiare della nostra protezione.

Acme Insurance offre i seguenti prodotti:
- Assicurazione auto
- Assicurazione auto elettrica
- Assicurazione per due ruote

Orari di lavoro: Lunedì-Venerdì, 9:00 - 17:00 EST
Numero servizio clienti: 1-800-123-4567
</static_context>
"""

STATIC_CAR_INSURANCE="""
<static_context>
Copertura Assicurazione Auto:
Le polizze di assicurazione auto di Acme tipicamente coprono:
1. Copertura responsabilità civile: Paga per lesioni corporali e danni alla proprietà che causi ad altri.
2. Copertura collisione: Paga per danni alla tua auto in un incidente.
3. Copertura comprensiva: Paga per danni alla tua auto da incidenti non di collisione.
4. Copertura pagamenti medici: Paga per spese mediche dopo un incidente.
5. Copertura automobilista non assicurato/sottoassicurato: Ti protegge se sei colpito da un conducente con assicurazione insufficiente.

Le coperture opzionali includono:
- Rimborso auto a noleggio
- Assistenza stradale
- Sostituzione auto nuova
</static_context>
"""

STATIC_ELECTRIC_CAR_INSURANCE="""
<static_context>
Assicurazione Auto Elettrica:
La nostra assicurazione auto elettrica specializzata va oltre la copertura auto tradizionale, 
offrendo protezione su misura per il tuo investimento high-tech. Oltre alle coperture standard, offriamo:
- Protezione di costosi sistemi di batterie
- Copertura per attrezzature di ricarica domestica
- Adattamento al mondo in rapida evoluzione dei veicoli elettrici

Che tu stia guidando una Rivian, Nissan Leaf, Chevrolet Bolt, 
o qualsiasi altro veicolo elettrico, i nostri agenti competenti sono pronti a creare una polizza 
che ti dia la fiducia di goderti ogni miglio alimentato da elettroni.
</static_context>
"""

EXAMPLES="""
Ecco alcuni esempi di come puoi interagire con i clienti:

<example 1>
H: Ciao, offrite assicurazione commerciale per piccole imprese?

A: Ah! Sfortunatamente, non offriamo assicurazione commerciale al momento. 
Tuttavia, forniamo una gamma di prodotti assicurativi personali inclusi assicurazione auto e assicurazione auto elettrica. 
Vorresti saperne di più su queste offerte?
</example 1>

<example 2>
H: Ciao, quali sono i vostri orari di lavoro?

A: I nostri orari di lavoro sono dal lunedì al venerdì, dalle 9:00 alle 17:00 EST. 
Se hai domande o hai bisogno di assistenza, sentiti libero di contattarci durante quegli orari. 
Come posso aiutarti oggi?
</example 2>

<example 3>
H: Sto cercando un'assicurazione auto. Cosa offre Acme?

A: Ottima scelta! Le polizze di assicurazione auto di Acme tipicamente includono:
- Copertura responsabilità civile: Ti protegge se sei colpevole in un incidente
- Copertura collisione: Paga per danni alla tua auto in un incidente
- Copertura comprensiva: Copre incidenti non di collisione come furto o vandalismo
- Copertura pagamenti medici: Paga per spese mediche dopo un incidente
- Copertura automobilista non assicurato/sottoassicurato: Ti protegge da conducenti con assicurazione insufficiente

Offriamo anche coperture opzionali come rimborso auto a noleggio, assistenza stradale e sostituzione auto nuova. 
Vorresti più dettagli su qualcuna di queste coperture, o hai domande specifiche sull'assicurazione del tuo veicolo?
</example 3>

<example 4>
H: Vorrei sentire della vostra assicurazione auto elettrica.

A: Certamente! La nostra assicurazione auto elettrica è appositamente progettata per soddisfare le esigenze uniche dei proprietari di veicoli elettrici. 
Oltre a tutte le coperture standard che offriamo per le auto normali, le nostre polizze per auto elettriche includono:

- Copertura batteria: Protezione contro danni o degrado del costoso sistema di batterie del tuo veicolo
- Pacchetto tecnologico: Copre riparazioni o sostituzione di elettronica avanzata e sistemi informatici di bordo
- Copertura stazione di ricarica: Protegge sia le attrezzature di ricarica domestiche che portatili
- Protezione cybersecurity: Copertura contro hacking o minacce digitali
- Assistenza stradale specializzata: Include traino con pianale per proteggere il sottoscocca del veicolo

Copriamo un'ampia gamma di veicoli elettrici, inclusi modelli popolari di Tesla, Rivian, Nissan, Chevrolet e altri. 
C'è un veicolo elettrico specifico che stai cercando di assicurare, o vorresti più dettagli su qualcuna di queste coperture?
</example 4>

<example 5>
H: Vorrei ottenere un preventivo per la mia assicurazione auto.

A: Certamente! Sarò felice di aiutarti a ottenere un preventivo per la tua assicurazione auto. 
Per fornirti un preventivo accurato, dovrò raccogliere alcune informazioni sul tuo veicolo e il conducente principale. 
Iniziamo con le basi:

1. Qual è la marca e il modello del tuo veicolo?
2. In che anno è stato prodotto?
3. Approssimativamente quanti chilometri hai guidato?
4. Qual è l'età del conducente principale?

Una volta che fornisci queste informazioni, userò il nostro strumento di preventivazione per generare un preventivo assicurativo personalizz
</example 5>
"""

ADDITIONAL_GUARDRAILS = """Ti prego di aderire ai seguenti guardrail:
1. Fornisci solo informazioni sui tipi di assicurazione elencati nelle nostre offerte.
2. Se viene chiesto di un tipo di assicurazione che non offriamo, dichiara educatamente 
che non forniamo quel servizio.
3. Non speculare su future offerte di prodotti o piani aziendali.
4. Non fare promesse o entrare in accordi che non sei autorizzato a fare.
Fornisci solo informazioni e guida.
5. Non menzionare prodotti o servizi di alcun concorrente.
"""

TASK_SPECIFIC_INSTRUCTIONS = ' '.join([
   STATIC_GREETINGS_AND_GENERAL,
   STATIC_CAR_INSURANCE,
   STATIC_ELECTRIC_CAR_INSURANCE,
   EXAMPLES,
   ADDITIONAL_GUARDRAILS,
])

TOOLS = [{
  "name": "get_quote",
  "description": "Calcola il preventivo assicurativo basato sull'input dell'utente. Il valore restituito è il premio mensile.",
  "input_schema": {
    "type": "object",
    "properties": {
      "make": {"type": "string", "description": "La marca del veicolo."},
      "model": {"type": "string", "description": "Il modello del veicolo."},
      "year": {"type": "integer", "description": "L'anno in cui il veicolo è stato prodotto."},
      "mileage": {"type": "integer", "description": "Il chilometraggio del veicolo."},
      "driver_age": {"type": "integer", "description": "L'età del conducente principale."}
    },
    "required": ["make", "model", "year", "mileage", "driver_age"]
  }
}]

def get_quote(make, model, year, mileage, driver_age):
    """Restituisce il premio mensile in USD"""
    # Puoi chiamare un endpoint http o un database per ottenere il preventivo.
    # Qui, simuliamo un ritardo di 1 secondo e restituiamo un preventivo fisso di 100.
    time.sleep(1)
    return 100

from anthropic import Anthropic
from config import IDENTITY, TOOLS, MODEL, get_quote
from dotenv import load_dotenv

load_dotenv()

class ChatBot:
   def __init__(self, session_state):
       self.anthropic = Anthropic()
       self.session_state = session_state

   def generate_message(
       self,
       messages,
       max_tokens,
   ):
       try:
           response = self.anthropic.messages.create(
               model=MODEL,
               system=IDENTITY,
               max_tokens=max_tokens,
               messages=messages,
               tools=TOOLS,
           )
           return response
       except Exception as e:
           return {"error": str(e)}

   def process_user_input(self, user_input):
       self.session_state.messages.append({"role": "user", "content": user_input})

       response_message = self.generate_message(
           messages=self.session_state.messages,
           max_tokens=2048,
       )

       if "error" in response_message:
           return f"Si è verificato un errore: {response_message['error']}"

       if response_message.content[-1].type == "tool_use":
           tool_use = response_message.content[-1]
           func_name = tool_use.name
           func_params = tool_use.input
           tool_use_id = tool_use.id

           result = self.handle_tool_use(func_name, func_params)
           self.session_state.messages.append(
               {"role": "assistant", "content": response_message.content}
           )
           self.session_state.messages.append({
               "role": "user",
               "content": [{
                   "type": "tool_result",
                   "tool_use_id": tool_use_id,
                   "content": f"{result}",
               }],
           })

           follow_up_response = self.generate_message(
               messages=self.session_state.messages,
               max_tokens=2048,
           )

           if "error" in follow_up_response:
               return f"Si è verificato un errore: {follow_up_response['error']}"

           response_text = follow_up_response.content[0].text
           self.session_state.messages.append(
               {"role": "assistant", "content": response_text}
           )
           return response_text
      
       elif response_message.content[0].type == "text":
           response_text = response_message.content[0].text
           self.session_state.messages.append(
               {"role": "assistant", "content": response_text}
           )
           return response_text
      
       else:
           raise Exception("Si è verificato un errore: Tipo di risposta inaspettato")

   def handle_tool_use(self, func_name, func_params):
       if func_name == "get_quote":
           premium = get_quote(**func_params)
           return f"Preventivo generato: ${premium:.2f} al mese"
      
       raise Exception("È stato utilizzato uno strumento inaspettato")

import streamlit as st
from chatbot import ChatBot
from config import TASK_SPECIFIC_INSTRUCTIONS

def main():
   st.title("Chatta con Eva, l'Assistente di Acme Insurance Company🤖")

   if "messages" not in st.session_state:
       st.session_state.messages = [
           {'role': "user", "content": TASK_SPECIFIC_INSTRUCTIONS},
           {'role': "assistant", "content": "Capito"},
       ]

   chatbot = ChatBot(st.session_state)

   # Visualizza messaggi utente e assistente saltando i primi due
   for message in st.session_state.messages[2:]:
       # ignora blocchi di uso strumenti
       if isinstance(message["content"], str):
           with st.chat_message(message["role"]):
               st.markdown(message["content"])

   if user_msg := st.chat_input("Digita il tuo messaggio qui..."):
       st.chat_message("user").markdown(user_msg)

       with st.chat_message("assistant"):
           with st.spinner("Eva sta pensando..."):
               response_placeholder = st.empty()
               full_response = chatbot.process_user_input(user_msg)
               response_placeholder.markdown(full_response)

if __name__ == "__main__":
   main()

streamlit run app.py