app.py

# ANALÍTICA BOUTIQUE, SC (https://www.visoresanalitica.com.mx/)
# DEMO
# 
# PROBLEM: 

# Multi-agent Collaboration for Financial Analysis
# Demostrate ways for making agents collaborate with each other.
# 

# python app.py

# Dependencies:
import gradio as gr
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
#from langchain_community.chat_message_histories import GradioChatMessageHistory
from langchain_community.chat_message_histories.in_memory import ChatMessageHistory
import os
import sys
import io
import pandas as pd
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
#from scrape_website_tool import ScrapeWebsiteTool
#from serper_dev_tool import SerperDevTool

#
# Obtener las API keys desde .env
openai_api_key = os.getenv("OPENAI_API_KEY")
serper_api_key = os.getenv("SERPER_API_KEY")

# Obtener las API keys desde SECRETS
#openai_api_key = st.secrets["OPENAI_API_KEY"]
#serper_api_key = st.secrets["SERPER_API_KEY"]

# Define the list of models and initialize your agents and tasks as per the earlier code
MODEL_LIST = ['gpt-4o-mini', 'gpt-4o']

# crewAI Tools
search_tool = SerperDevTool()
scrape_tool = ScrapeWebsiteTool()

# Define Gradio interface components
def execute_financial_analysis( stock_selection, model_option, initial_capital, risk_tolerance, trading_strategy_preference ):
    sys.stdout = io.StringIO()  # Capture output to display in the interface
    
    # Setup the environment based on model selection
    os.environ["OPENAI_MODEL_NAME"] = model_option
    
    # Creating Agents
    # Agent: Data Analyst
    data_analyst_agent = Agent(
        role="Data Analyst",
        goal="Monitor and analyze market data in real-time "
            "to identify trends and predict market movements.",
        backstory="Specializing in financial markets, this agent "
                "uses statistical modeling and machine learning "
                "to provide crucial insights. With a knack for data, "
                "the Data Analyst Agent is the cornerstone for "
                "informing trading decisions.",
        verbose=True,
        allow_delegation=True,
        tools = [scrape_tool, search_tool]
    )
    # Agent: Trading Strategy Developer 
    trading_strategy_agent = Agent(
        role="Trading Strategy Developer",
        goal="Develop and test various trading strategies based "
            "on insights from the Data Analyst Agent.",
        backstory="Equipped with a deep understanding of financial "
                "markets and quantitative analysis, this agent "
                "devises and refines trading strategies. It evaluates "
                "the performance of different approaches to determine "
                "the most profitable and risk-averse options.",
        verbose=True,
        allow_delegation=True,
        tools = [scrape_tool, search_tool]
    )
    # Agent: Trade Advisor
    execution_agent = Agent(
        role="Trade Advisor",
        goal="Suggest optimal trade execution strategies "
            "based on approved trading strategies.",
        backstory="This agent specializes in analyzing the timing, price, "
                "and logistical details of potential trades. By evaluating "
                "these factors, it provides well-founded suggestions for "
                "when and how trades should be executed to maximize "
                "efficiency and adherence to strategy.",
        verbose=True,
        allow_delegation=True,
        tools = [scrape_tool, search_tool]
    )
    # Agent: Risk Advisor
    risk_management_agent = Agent(
        role="Risk Advisor",
        goal="Evaluate and provide insights on the risks "
            "associated with potential trading activities.",
        backstory="Armed with a deep understanding of risk assessment models "
                "and market dynamics, this agent scrutinizes the potential "
                "risks of proposed trades. It offers a detailed analysis of "
                "risk exposure and suggests safeguards to ensure that "
                "trading activities align with the firm’s risk tolerance.",
        verbose=True,
        allow_delegation=True,
        tools = [scrape_tool, search_tool]
    )

    # Creating Tasks
    # Task for Data Analyst Agent: Analyze Market Data
    data_analysis_task = Task(
        description=(
            "Continuously monitor and analyze market data for "
            "the selected stock ({stock_selection}). "
            "Use statistical modeling and machine learning to "
            "identify trends and predict market movements."
        ),
        expected_output=(
            "Insights and alerts about significant market "
            "opportunities or threats for {stock_selection}."
        ),
        agent=data_analyst_agent,
    )

    # Task for Trading Strategy Agent: Develop Trading Strategies
    strategy_development_task = Task(
        description=(
            "Develop and refine trading strategies based on "
            "the insights from the Data Analyst and "
            "user-defined risk tolerance ({risk_tolerance}). "
            "Consider trading preferences ({trading_strategy_preference})."
        ),
        expected_output=(
            "A set of potential trading strategies for {stock_selection} "
            "that align with the user's risk tolerance."
        ),
        agent=trading_strategy_agent,
    )

    # Task for Trade Advisor Agent: Plan Trade Execution
    execution_planning_task = Task(
        description=(
            "Analyze approved trading strategies to determine the "
            "best execution methods for {stock_selection}, "
            "considering current market conditions and optimal pricing."
        ),
        expected_output=(
            "Detailed execution plans suggesting how and when to "
            "execute trades for {stock_selection}."
        ),
        agent=execution_agent,
    )

    # Task for Risk Advisor Agent: Assess Trading Risks
    risk_assessment_task = Task(
        description=(
            "Evaluate the risks associated with the proposed trading "
            "strategies and execution plans for {stock_selection}. "
            "Provide a detailed analysis of potential risks "
            "and suggest mitigation strategies."
        ),
        expected_output=(
            "A comprehensive risk analysis report detailing potential "
            "risks and mitigation recommendations for {stock_selection}."
            "Provide your final answer in Spanish."
        ),
        agent=risk_management_agent,
    )
    
    # Creating the Crew
    # Note: The Process class helps to delegate the workflow to the Agents (kind of like a Manager at work)
    #       In this example, it will run this hierarchically.
    #       manager_llm lets you choose the "manager" LLM you want to use.

    # Define the crew with agents and tasks
    financial_trading_crew = Crew(
        agents=[data_analyst_agent,
                trading_strategy_agent,
                execution_agent,
                risk_management_agent],

        tasks=[data_analysis_task,
            strategy_development_task,
            execution_planning_task,
            risk_assessment_task],

        manager_llm=ChatOpenAI(model=model_option,
                            temperature=0.7),
        process=Process.hierarchical,
        verbose=True
    )
    
    # Define your inputs
    financial_trading_inputs = {
        'stock_selection': stock_selection,
        'initial_capital': initial_capital,
        'risk_tolerance': risk_tolerance,
        'trading_strategy_preference': trading_strategy_preference,
        'news_impact_consideration': True
    }

    # Execute your Crew process
    result = financial_trading_crew.kickoff(inputs=financial_trading_inputs)
    verbose_output = sys.stdout.getvalue()
    sys.stdout = sys.__stdout__  # Restaurar la salida estándar

    # Convertir el objeto 'result' a cadena para que Gradio pueda procesarlo
    return str(result), verbose_output

#
#execute_financial_analysis( 'VOD', 'gpt-4o-mini', '100000', 'Medium', 'Day Trading' )

#
with gr.Blocks() as demo:
    gr.Markdown("# Colaboración Multiagente para el Análisis Financiero")
    with gr.Sidebar():
        gr.Markdown("# DEMO")
        gr.Image("images/Logo_AB.png")
        gr.Markdown("Contact: [email protected] [email protected]")
        gr.Markdown("## Configuración del Modelo")
        model_option = gr.Dropdown(MODEL_LIST, label="Choose OpenAI model", value='gpt-4o-mini')

    gr.Markdown("## Configuración")
    gr.Markdown("""
        ## 📊 AI Agents para Análisis de Trading
        
        **Este DEMO crea un sistema de agentes de inteligencia artificial (AI Agents) para analizar datos del mercado financiero y sugerir estrategias de trading para un activo.**
        La tripulación de agentes incluye a:
        * Data Analyst
        * Trading Strategy Developer
        * Trade Advisor
        * Risk Advisor
        
        Todos, con herramientas de acceso a información en tiempo real que sea disponible en Internet.
        Por favor, selecciona el **Ticker** respecto del cual quieras el análisis financiero.
        
        Algunos ejemplos son:
        - VOD - Nasdaq Index
        - AAPL - Apple
        - GOOG - Alphabet (Google)
        - INTC - Intel
        - BTC-USD - Bitcoin USD
        """)
    ticker = gr.Textbox(label="Introduce el Ticker del activo financiero (Ej: AAPL):", value="AAPL")
    initial_capital = gr.Textbox(label="Initial Capital", value="100000")
    risk_tolerance = gr.Radio(label="Risk Tolerance", choices=["Low", "Medium", "High"], value="Medium")
    trading_strategy_preference = gr.Radio(label="Trading Strategy Preference", choices=["Day Trading", "Swing Trading", "Long Term"], value="Day Trading")
    execute_button = gr.Button("🚀 Iniciar Análisis")

    gr.Markdown("## 📌 Resultado Final")
    result_display = gr.Markdown()
    verbose_output = gr.Textbox(label="🔎 Detalle del Proceso de Razonamiento", lines=10)

    execute_button.click(
        execute_financial_analysis,
        inputs=[ticker, model_option, initial_capital, risk_tolerance, trading_strategy_preference],
        outputs=[result_display, verbose_output]
    )
#
demo.launch()