Download src/main.py from AIterAI/Finova: direct link, hf CLI and curl.
- Browser
- Download file 9.81 kB
-
https://huggingface.co/spaces/AIterAI/Finova/resolve/main/src/main.py
- Command line
-
hf download hf://spaces/AIterAI/Finova/src/main.py
-
curl -L -o main.py https://huggingface.co/spaces/AIterAI/Finova/resolve/main/src/main.py
9.81 kB
| import gradio as gr | |
| import asyncio | |
| import os | |
| import logging | |
| from dotenv import load_dotenv | |
| from google.adk.sessions import DatabaseSessionService | |
| from google.adk.runners import Runner | |
| from google.genai import types | |
| from huggingface_hub import HfApi, HfApiHTTPError | |
| # Asumsi struktur proyek Anda dipertahankan | |
| from src.logging import setup_logging | |
| from src.db import DB_PATH, DB_URL, engine, initialize_db | |
| from src.agents.agent import finova # Impor agen utama | |
| from src.utils import display_state, process_agent_response | |
| # --- Inisialisasi --- | |
| load_dotenv() | |
| setup_logging() | |
| logger = logging.getLogger(__name__) | |
| # Setup Langfuse (Opsional) | |
| def setup_tracing(): | |
| """Setup tracing for observability""" | |
| if os.getenv("LANGFUSE_PUBLIC_KEY") and os.getenv("LANGFUSE_SECRET_KEY"): | |
| try: | |
| from langfuse import get_client | |
| langfuse = get_client() | |
| if langfuse.auth_check(): | |
| logger.info("Langfuse client authenticated. Observability ENABLED.") | |
| from openinference.instrumentation.google_adk import GoogleADKInstrumentor | |
| GoogleADKInstrumentor().instrument() | |
| else: | |
| logger.warning("Langfuse client authentication failed") | |
| except ImportError: | |
| logger.warning("Langfuse not installed. pip install langfuse openinference-instrumentation-google-adk") | |
| except Exception as e: | |
| logger.error(f"Error setting up Langfuse: {e}") | |
| else: | |
| logger.warning("Langfuse observability is DISABLED. Set LANGFUSE keys to enable.") | |
| # Setup Database | |
| def setup_database(): | |
| """Periksa database dan inisialisasi jika tidak ditemukan""" | |
| if not os.path.exists(DB_PATH): | |
| logger.warning("Database not found. Initializing...") | |
| try: | |
| initialize_db(engine) | |
| logger.info(f"Database created successfully at: {DB_PATH}") | |
| except Exception as e: | |
| logger.critical(f"Error initializing database: {e}") | |
| raise | |
| else: | |
| logger.info("Database already exists. Skipping initialization.") | |
| logger.info("==================== GRADIO APP START ====================") | |
| setup_tracing() # Opsional | |
| setup_database() | |
| # Setup Session Service dan Runner | |
| session_service = DatabaseSessionService(db_url=DB_URL) | |
| APP_NAME = "FinovaGradio" # Nama aplikasi yang konsisten | |
| # State Awal | |
| initial_state = { | |
| "user:name": "User", | |
| "user:balance": 0, | |
| "user:language": "eng", | |
| "user:currency": "USD", | |
| "user:financial_goals": [] | |
| } | |
| runner = Runner( | |
| app_name=APP_NAME, | |
| agent=finova, | |
| session_service=session_service, | |
| ) | |
| # --- Logika Antarmuka Gradio --- | |
| async def get_user_id( | |
| hf_token: gr.OAuthToken | None, | |
| request: gr.Request | |
| ) -> str: | |
| """ | |
| Mendapatkan user_id yang unik. | |
| Prioritas: Login HF > Session Hash Anonim. | |
| """ | |
| user_id = None | |
| if hf_token: | |
| try: | |
| # Gunakan token untuk mendapatkan info pengguna | |
| user_info = await asyncio.to_thread( | |
| HfApi().whoami, token=hf_token.token | |
| ) | |
| user_id = user_info['name'] # 'name' adalah username HF | |
| logger.info(f"Using Hugging Face user ID: {user_id}") | |
| except HfApiHTTPError as e: | |
| logger.warning(f"Failed to get HF user info with token: {e}. Using session hash.") | |
| user_id = request.session_hash # Fallback | |
| except Exception as e: | |
| logger.error(f"Error during HF whoami check: {e}. Using session hash.") | |
| user_id = request.session_hash # Fallback | |
| else: | |
| # Pengguna tidak login | |
| logger.info("No HF token. Using Gradio session hash for anonymous user.") | |
| user_id = request.session_hash | |
| return user_id | |
| async def get_or_create_adk_session( | |
| user_id: str, | |
| adk_session_state: str | None | |
| ) -> str: | |
| """ | |
| Mendapatkan atau membuat sesi ADK untuk user_id yang diberikan. | |
| """ | |
| adk_session_id = adk_session_state | |
| if adk_session_id is None: | |
| logger.info(f"No existing ADK session state. Checking DB for user: {user_id}") | |
| # Periksa apakah sesi SUDAH ADA untuk user_id ini di DB | |
| # (Berguna untuk pengguna HF yang login me-refresh browser) | |
| existing_sessions = [] | |
| try: | |
| session_list = await session_service.list_sessions( | |
| app_name=APP_NAME, user_id=user_id | |
| ) | |
| existing_sessions = session_list.sessions | |
| except Exception as e: | |
| logger.warning(f"Could not list existing sessions for user {user_id}: {e}") | |
| if existing_sessions: | |
| # Gunakan kembali sesi terbaru | |
| adk_session_id = existing_sessions[-1].id | |
| logger.info(f"Reusing existing ADK session {adk_session_id} from DB for user {user_id}") | |
| else: | |
| # Buat sesi yang benar-benar baru | |
| logger.info(f"Creating new ADK session for user: {user_id}") | |
| new_session = await session_service.create_session( | |
| app_name=APP_NAME, | |
| user_id=user_id, | |
| state=initial_state, | |
| ) | |
| adk_session_id = new_session.id | |
| logger.info(f"Created new ADK session: {adk_session_id} for user: {user_id}") | |
| else: | |
| logger.info(f"Using existing ADK session from state: {adk_session_id} for user: {user_id}") | |
| return adk_session_id | |
| async def chat_interface( | |
| message: str, | |
| history: list, | |
| adk_session_state: str | None, # Dari additional_inputs | |
| request: gr.Request, # Input implisit | |
| hf_token: gr.OAuthToken | None # Input implisit dari login | |
| ): | |
| """ | |
| Menangani interaksi chat dengan agen Finova melalui Gradio. | |
| Mengelola sesi pengguna berdasarkan login HF atau session hash. | |
| Args: | |
| message: Pesan input dari pengguna. | |
| history: Riwayat percakapan. | |
| adk_session_state: State dari Gradio, menyimpan ADK session_id. | |
| request: Objek Gradio Request untuk session hash (fallback). | |
| hf_token: Objek Gradio OAuthToken (jika pengguna login). | |
| Returns: | |
| Tuple: (respons_teks_final, adk_session_state_baru) | |
| """ | |
| try: | |
| # 1. Dapatkan User ID (dari HF Login atau Session Hash) | |
| user_id = await get_user_id(hf_token, request) | |
| # 2. Dapatkan atau Buat Sesi ADK | |
| adk_session_id = await get_or_create_adk_session(user_id, adk_session_state) | |
| # 3. Jalankan agent | |
| logger.info(f"User query: {message}") | |
| content = types.Content(role="user", parts=[types.Part(text=message)]) | |
| final_response_text = "Sorry, I couldn't process that." | |
| async for event in runner.run_async( | |
| user_id=user_id, session_id=adk_session_id, new_message=content | |
| ): | |
| response = await process_agent_response(event) | |
| if response: | |
| final_response_text = response | |
| logger.info(f"Agent response: {final_response_text}") | |
| # 4. Kembalikan respons dan state yang diperbarui | |
| return final_response_text, adk_session_id | |
| except Exception as e: | |
| logger.error(f"Error during chat interaction for user {user_id}: {e}", exc_info=True) | |
| # Jika terjadi error, laporkan error dan reset state ke None. | |
| return f"An error occurred: {e}", None | |
| # --- Luncurkan Gradio --- | |
| if __name__ == "__main__": | |
| with gr.Blocks( | |
| theme=gr.themes.Default(primary_hue="blue", secondary_hue="neutral") | |
| ) as demo: | |
| # State untuk menyimpan ID Sesi ADK di seluruh giliran | |
| adk_session_state = gr.State(None) | |
| with gr.Sidebar(): | |
| gr.Markdown("## Login") | |
| gr.Markdown( | |
| "Login dengan akun Hugging Face Anda untuk menyimpan riwayat percakapan Anda." | |
| ) | |
| gr.LoginButton() # Tombol Login OAuth | |
| gr.Markdown("---") | |
| gr.Markdown("### Tentang Finova") | |
| gr.Markdown( | |
| "Finova adalah asisten keuangan pribadi Anda, " | |
| "diberdayakan oleh Google ADK dan model Gemini." | |
| ) | |
| with gr.Column(): | |
| chatbot = gr.ChatInterface( | |
| fn=chat_interface, | |
| # 'fn' akan menerima argumen implisit 'request' dan 'hf_token' | |
| # 'adk_session_state' harus didefinisikan secara eksplisit | |
| additional_inputs=[adk_session_state], | |
| additional_outputs=[adk_session_state], | |
| title="Finova Chatbot", | |
| description="Your Agentic Financial Assistant. Interact using natural language.", | |
| examples=[ | |
| "Hello", | |
| "I bought groceries for 50 dollars", | |
| "I received my salary of 2000", | |
| "What's my current balance?", | |
| "Add a goal: Save for a vacation", | |
| "What is a good way to start investing?" | |
| ], | |
| retry_btn=None, | |
| undo_btn="Delete Previous", | |
| clear_btn="Clear Chat", | |
| ) | |
| # Saat "Clear Chat" diklik, kita juga harus me-reset state sesi ADK | |
| def clear_session_state(): | |
| logger.info("Chat cleared by user. Resetting ADK session state.") | |
| return None # Kembalikan None untuk me-reset state | |
| chatbot.clear_btn.click( | |
| fn=clear_session_state, | |
| inputs=[], | |
| outputs=[adk_session_state], | |
| queue=False # Jalankan ini dengan cepat tanpa antrian | |
| ) | |
| # Metode launch Gradio menangani event loop | |
| demo.launch() | |
| logger.info("==================== GRADIO APP END ====================") |