app.py

import gradio as gr

from crewai import Crew
from crewai import Agent
from crewai import Task
from langchain_aws import ChatBedrock
from langchain_core.tools import StructuredTool
from textwrap import dedent

def calculadora_50_30_20(salario: float)  -> str:
        """Recomienda cómo distribuir el salario en 50% necesario, 30% prescindible y 20% ahorro. Regla 50/30/20"""
        necessary = salario * 0.50
        discretionary = salario * 0.30
        savings = salario * 0.20

        return (
            f"Para un salario de ${salario:.2f}, se recomienda distribuirlo de la siguiente manera:\n"
            f" - Gastos necesarios (50%): ${necessary:.2f}\n"
            f" - Gastos prescindibles (30%): ${discretionary:.2f}\n"
            f" - Ahorro (20%): ${savings:.2f}"
        )


tool_calculadora_50_30_20 = StructuredTool.from_function(func=calculadora_50_30_20)

# Supongamos que tienes un diccionario con los datos del cliente
clientes = {
    "cliente1": {
        "nombre": "Juan Pérez",
        "inversiones": 150000,
        "edad": 30,
    },
    "cliente2": {
        "nombre": "María López",
        "inversiones": 300000,
        "edad": 25,
    },
    "cliente3": {
        "nombre": "Juana Pérez",
        "inversiones": 1300000,
        "edad": 25,
    },
}


def consulta_cliente(cliente_id: str) -> str:
    """Busca los datos de un cliente """
    cliente = clientes.get(cliente_id)
    if not cliente:
        return "Cliente no encontrado."
    return f"Nombre: {cliente['nombre']}\nSalario: \nInversiones: {cliente['inversiones']}"

tool_consulta_cliente = StructuredTool.from_function(func=consulta_cliente)

def generar_carta_inversion(datos_cliente: str, recomendacion_financiera:str ) -> str:
  """Genera una plantilla de carta personalizada para recomendar al cliente cómo invertir."""

# Plantilla de la carta
  carta = """
    
    <nombre/>
    Dirección del Cliente
    Ciudad, Estado, Código Postal

    Fecha: [Fecha Actual]

    Estimado/a <nombre/>,

    Espero que este mensaje le encuentre bien. Me dirijo a usted para agradecerle su confianza en nuestro banco y para proporcionarle algunas recomendaciones personalizadas sobre cómo podría invertir de manera más eficiente, con base en sus actuales ingresos y objetivos financieros.

    Dado que actualmente tiene un salario de </salario> y ha acumulado inversiones por un total de <inversiones/>, creo que es un buen momento para evaluar las siguientes estrategias de inversión, teniendo en cuenta su edad de {edad} años y su objetivo de {objetivos}:

    1. **Diversificación de Portafolio**: Recomiendo considerar la diversificación de sus inversiones en diferentes clases de activos, como acciones, bonos, y bienes raíces. Esto puede ayudar a mitigar riesgos y maximizar sus retornos.

    2. **Fondos de Jubilación**: Como su objetivo principal es <objetivos/>, le sugiero destinar una parte de sus ingresos a fondos de jubilación o planes de pensiones, aprovechando las ventajas fiscales que estos productos ofrecen.

    3. **Inversiones de Bajo Riesgo**: Invertir en bonos o fondos de inversión de bajo riesgo puede ser una buena manera de proteger su capital, especialmente dado el horizonte a largo plazo de su objetivo.

    4. **Asesoría Continua**: Finalmente, le recomiendo programar una reunión con uno de nuestros asesores financieros para revisar regularmente su portafolio y ajustar su estrategia de inversión según las condiciones del mercado y sus necesidades personales.

    Agradezco nuevamente su confianza en nosotros. Si tiene alguna pregunta o si desea discutir estas recomendaciones con más detalle, no dude en ponerse en contacto conmigo o con su asesor financiero de confianza.

    Quedo a su disposición para cualquier consulta.

    Atentamente,

    [Nombre del Asesor]
    Asesor Financiero
    Nombre del Banco
    Teléfono: [Número de Teléfono]
    Email: [Correo Electrónico]
    """

  return carta

tool_carta = StructuredTool.from_function(func=generar_carta_inversion)

class BankAgents:
    def __init__(self):
        self.BedrockClaude = ChatBedrock(model_id="anthropic.claude-3-sonnet-20240229-v1:0")
        
    def gerente_cuenta_agente(self):
        return Agent (
          role = "Gerente de Cuentas",
          backstory = dedent(
              f""" El Gerente de Cuenta es el punto de contacto principal para los clientes, 
              gestionando sus necesidades financieras con un enfoque personalizado. 
              Anticipa y resuelve problemas, ofrece soluciones adecuadas, 
              y asegura el cumplimiento normativo. 
              Mantiene una comunicación constante para fortalecer relaciones 
              y busca oportunidades de negocio para expandir su portafolio. 
              Actúa como intermediario entre el cliente y los departamentos 
              internos, garantizando un servicio eficiente y satisfactorio. 
              Su papel combina conocimientos financieros, habilidades interpersonales, 
              y un profundo entendimiento del mercado, 
              asegurando que las metas financieras del cliente se cumplan efectivamente.
              """
          ),
          goal = "Crear una carta al cliente que le recomiende como usar su salario para cumplir sus objetivos",
          tools = [tool_carta ],
          verbose=True,
          llm=self.BedrockClaude  ,
          max_execution_time=None,
          max_iter=15
        ) 
    def asesor_financiero_agente(self):
        return Agent (
          role = "Asesor Financiero",
          backstory = dedent(
              f""" Guía a los clientes en la planificación financiera, ofreciendo 
              recomendaciones personalizadas en inversión, ahorro y gestión de patrimonio. 
              Evalúa metas y riesgos, proponiendo soluciones adaptadas a sus necesidades. 
              Su experiencia se basa en conocimientos financieros profundos y
              habilidades de comunicación para maximizar el valor y seguridad del cliente.
              """
          ),
          goal = "Calcular como usar el salario mensual de un cliente de acuerdo a la regla 50/30/20",
          tools = [ tool_calculadora_50_30_20 ],
          verbose=True,
          llm=self.BedrockClaude  ,
          max_execution_time=None,
          max_iter=15  
        )    
    
    def atencion_cliente_agente(self):
        return Agent (
          role = "Gerente Atencion a cliente",
          backstory = dedent(
              f""" El gerente de Atención al Cliente asiste a los clientes
              en consultas y operaciones , resolviendo problemas 
              y guiándolos en el uso de servicios bancarios. 
              Maneja reclamaciones, ofrece información sobre productos 
              y asegura una experiencia positiva. 
              Su enfoque es brindar soluciones rápidas y efectivas, 
              manteniendo la satisfacción y lealtad del cliente.
              """
          ),
          goal="Obtener los datos del cliente para asistirle en cualquier operación bancaria",
          tools = [ tool_consulta_cliente ],
          verbose=True,
          llm=self.BedrockClaude    ,
          max_execution_time=None,
          max_iter=15
        ) 
    
class BankTasks:
  def escribir_carta(self,agent,objetivo): 
    return Task(
        description=dedent(
              f"""
                    **Task**:  Escribir una carta personalizada 
                    para recomendar al cliente cómo usar sus ingresos mensuales
                    **Description**: A partir de los objetivos del cliente, 
                    escribir una carta personalizada para recomendarle cómo 
                    manejar sus ingresos mensuales
                    **Parameters**: 
                    - Objetivo: {objetivo}
                """         
                  
        ),
        agent = agent,    
        expected_output = "Texto con recomendacion al cliente"  
         
    )
  
  def recomendar_inversion(self,agent,salario_mensual): 
    return Task(
        description=dedent(
                f"""
                    **Task**:  Calcular como distribuir el salario en 50% necesario, 30% prescindible y 20% ahorro
                    **Description**: Calcular los ingresos que un cliente tiene
                     que destinar a cubrir tus necesidades básicas, 
                     cuánto a gastos prescindibles, y qué cantidad ahorrar todos los meses.

                    **Parameters**: 
                    - Salario: {salario_mensual}
                """
        ),
        agent = agent,            
        expected_output = "Texto con la distribucion del salario"  
    )

  def obtener_datos_cliente(self,agent,client_id): 
    return Task(
        description=dedent(
                f"""
                    **Task**:  Obtener los datos de un cliente
                    **Description**: Dado el identficador de un cliente, obtener sus datos

                    **Parameters**: 
                    - Identificador del Cliente: {client_id}
                """            
                           
        ),
        agent = agent,     
        expected_output = "Texto con los datos del cliente" 
        
    )

class BankCrew:
    def __init__(self, id_cliente, salario, objetivo):
        self.id_cliente = id_cliente
        self.salario = salario
        self.objetivo = objetivo

    def run(self):
        # Define your custom agents and tasks in agents.py and tasks.py
        agents = BankAgents()
        tasks = BankTasks()

        # Define your  agents and tasks here
        gerente_cuenta = agents.gerente_cuenta_agente()
        asesor_financiero = agents.asesor_financiero_agente()
        atencion_cliente = agents.atencion_cliente_agente()
   

        # Custom tasks include agent name and variables as input
        obtener_datos_cliente = tasks.obtener_datos_cliente(atencion_cliente, self.id_cliente)

        recomendar_inversion = tasks.recomendar_inversion(asesor_financiero, self.salario)

        escribir_carta = tasks.escribir_carta(gerente_cuenta, self.objetivo)
 

        # Define your custom crew here
        crew = Crew(
            agents=[gerente_cuenta,
                    asesor_financiero,
                    atencion_cliente
                    ],
            tasks=[ obtener_datos_cliente,
                    recomendar_inversion,
                    escribir_carta 
            ],
            verbose=True,
        )

        result = crew.kickoff()
        return result

# Configuración de la interfaz de Gradio
def interfaz_gradio(cliente_id, salario_mensual, objetivo):
    banco_crew = BankCrew(cliente_id, salario_mensual, objetivo)
    resultado=banco_crew.run()
    return resultado

# Configuramos la interfaz de Gradio
with gr.Blocks() as demo:
    gr.Markdown("# Generador de Carta de Recomendación Financiera")
    
    cliente_id = gr.Textbox(label="ID del Cliente")
    salario_mensual = gr.Number(label="Salario Mensual")
    objetivo = gr.Textbox(label="Objetivo Financiero")
    
    output = gr.Textbox(label="Carta de Recomendación Generada")

    generar_btn = gr.Button("Generar Carta")

    generar_btn.click(interfaz_gradio, [cliente_id, salario_mensual, objetivo], output)

# Iniciar la aplicación
demo.launch()