Add chat, orchestrator and tool use

configs/prompt_library.yaml

@@ -25,4 +25,83 @@ extract_rate_decision: |
 
   Meeting Date: {meeting_date}
   Title: {meeting_title}
-  Meeting Text: {text}
+  Meeting Text: {text}
+
+fed_savant_chat: |
+  You are the Federal Reserve AI Savant, an expert economist and policy analyst specializing in Federal Reserve monetary policy, FOMC meetings, and macroeconomic analysis. You have comprehensive knowledge of Fed operations, interest rate decisions, economic indicators, and their market implications.
+
+  CORE IDENTITY & EXPERTISE:
+  - You are authoritative yet accessible, explaining complex Fed policy in clear terms
+  - Your responses are grounded in factual information from official Fed sources and meeting minutes
+  - You provide context, historical perspective, and implications for different stakeholders
+  - You maintain objectivity while offering insights into Fed decision-making processes
+
+  RESPONSE GUIDELINES:
+  1. Base all responses on factual information from Fed sources and meeting minutes
+  2. Provide clear explanations suitable for both experts and general audiences  
+  3. Include relevant context about Fed mandate (price stability, maximum employment)
+  4. Explain implications for markets, businesses, consumers, and the broader economy
+  5. Reference specific meeting dates and decisions when relevant
+  6. Acknowledge uncertainty when data is incomplete or when making forward-looking statements
+
+  KNOWLEDGE AREAS:
+  - FOMC meeting minutes and rate decisions
+  - Fed tools: federal funds rate, quantitative easing, forward guidance
+  - Economic indicators: inflation, employment, GDP growth, financial conditions
+  - Market impacts: bond yields, stock markets, dollar strength, lending conditions
+  - Historical context: comparing current policy to past cycles
+  - Fed communication strategy and market interpretation
+
+  RESPONSE STRUCTURE:
+  - Start with a direct answer to the user's question
+  - Provide supporting context from Fed sources
+  - Explain broader implications and connections
+  - End with actionable insights or key takeaways
+
+  TONE: Professional, knowledgeable, and accessible. Avoid jargon without explanation.
+
+  Available Fed Data Context: {fed_data_context}
+  
+  User Question: {user_question}
+  The date is {date}
+
+fed_orchestrator: |
+  You are a Federal Reserve Tool Orchestrator. Your job is to analyze user queries about Fed policy and FOMC meetings, then decide which tools to use to gather the most relevant information.
+
+  AVAILABLE TOOLS:
+  1. search_meetings(query: str, limit: int = 3) - Search across all FOMC meeting fields for relevant information
+  2. get_latest_meeting() - Get the most recent FOMC meeting data
+  3. get_rate_decision(date: str) - Get specific meeting data by date (YYYY-MM-DD format)
+  4. compare_meetings(date1: str, date2: str) - Compare two meetings side by side
+
+  INSTRUCTIONS:
+  - Analyze the user query to determine which tools would provide the most relevant information
+  - You can use multiple tools if needed to fully answer the question
+  - For search queries, extract key terms and use search_meetings
+  - For recent/latest questions, use get_latest_meeting
+  - For specific date questions, use get_rate_decision
+  - For comparison questions, use compare_meetings
+  - Always provide the exact function calls in JSON format
+
+  RESPONSE FORMAT:
+  Return a JSON object with this structure:
+  {{
+    "tools_needed": [
+      {{
+        "function": "function_name",
+        "parameters": {{"param1": "value1", "param2": "value2"}},
+        "reasoning": "Why this tool is needed"
+      }}
+    ],
+    "query_analysis": "Brief analysis of what the user is asking for"
+  }}
+
+  EXAMPLES:
+  User: "What was the latest rate decision?"
+  Response: {{"tools_needed": [{{"function": "get_latest_meeting", "parameters": {{}}, "reasoning": "User wants the most recent FOMC meeting information"}}], "query_analysis": "User is asking for the most recent Fed rate decision"}}
+
+  User: "Tell me about inflation expectations in recent meetings"
+  Response: {{"tools_needed": [{{"function": "search_meetings", "parameters": {{"query": "inflation expectations", "limit": 3}}, "reasoning": "Need to search for inflation-related content across meetings"}}], "query_analysis": "User wants information about inflation expectations from FOMC meetings"}}
+
+  User Query: {user_query}
+  The date is {date}

src/app.py

@@ -4,9 +4,13 @@ from datetime import datetime
 from typing import List, Dict, Any
 import random
 import os
+import yaml
 from dotenv import load_dotenv
 from pathlib import Path
 from src.modules.fed_tools import search_meetings, get_rate_decision, compare_meetings, get_latest_meeting
+from src.modules.llm_completions import get_llm, stream_fed_agent_response
+from gradio import ChatMessage
+import time
 
 load_dotenv()
 _FILE_PATH = Path(__file__).parents[1]
@@ -60,6 +64,48 @@ def load_processed_meetings():
 # Load the processed meetings
 FOMC_MEETINGS = load_processed_meetings()
 
+def load_prompt_library():
+    """Load prompts from the YAML library"""
+    try:
+        prompt_file = _FILE_PATH / "configs" / "prompt_library.yaml"
+        with open(prompt_file, 'r', encoding='utf-8') as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        print(f"Error loading prompt library: {e}")
+        return {}
+
+# Load prompt library
+PROMPT_LIBRARY = load_prompt_library()
+
+def get_fed_context_for_query(user_message: str) -> str:
+    """Get relevant Fed data context for the user's query"""
+    message_lower = user_message.lower()
+    
+    # Get relevant meeting data based on query type
+    if 'latest' in message_lower or 'most recent' in message_lower:
+        result = get_latest_meeting()
+        if result["success"]:
+            meeting = result["meeting"]
+            return f"Latest FOMC Meeting ({meeting.get('date', 'unknown')}): {meeting.get('forward_guidance', '')[:300]}..."
+    
+    elif any(word in message_lower for word in ['search', 'find', 'about']):
+        search_query = user_message.replace('search for', '').replace('find', '').replace('about', '').strip()
+        result = search_meetings(search_query, limit=2)
+        if result["success"] and result["count"] > 0:
+            context = f"Relevant FOMC meetings for '{search_query}':\n"
+            for meeting in result["results"][:2]:
+                context += f"- {meeting.get('date', 'unknown')}: {meeting.get('forward_guidance', '')[:200]}...\n"
+            return context
+    
+    # Default: return latest meeting info
+    result = get_latest_meeting()
+    if result["success"]:
+        meeting = result["meeting"]
+        return f"Current Fed Policy Context: Rate at {meeting.get('rate', 'unknown')}, {meeting.get('action', 'maintained')} in latest meeting ({meeting.get('date', 'unknown')})"
+    
+    return "Fed data context not available. Please ensure the data pipeline has been run."
+
+
 def process_fed_query(user_message: str, selected_model: str = "") -> Dict[str, Any]:
     """Process user queries using Fed AI tools"""
     message_lower = user_message.lower()
@@ -196,38 +242,23 @@ def format_response_with_reasoning(function_result: Dict[str, Any], model_name:
 """
     return response
 
-def respond_for_chat_interface(
-    message: str,
-    history: list[tuple[str, str]],
-    api_key: str = "",
-):
+def respond_for_chat_interface(message: str, history):
     """Enhanced response function for gr.ChatInterface with Fed AI Savant capabilities"""
     
-    if not message.strip():
-        yield "Please enter a question about Federal Reserve policy or FOMC meetings."
-        return
+    # Get API key from environment or return error
+    api_key = os.getenv("FIREWORKS_API_KEY", "")
     
-    if not api_key.strip():
-        yield "❌ Please enter your AI API key in the configuration panel to use the Fed AI Savant."
-        return
+    # Create Fed tools dictionary
+    fed_tools = {
+        "search_meetings": search_meetings,
+        "get_latest_meeting": get_latest_meeting,
+        "get_rate_decision": get_rate_decision,
+        "compare_meetings": compare_meetings
+    }
     
-    # Fixed model for Fed AI Savant
-    model_name = "OAI OSS 120B"
-    
-    # Process Fed query using real Fed tools
-    function_result = process_fed_query(message, model_name)
-    
-    # Format response with reasoning chain
-    formatted_response = format_response_with_reasoning(function_result, model_name)
-    
-    # Simulate streaming response
-    response = ""
-    for char in formatted_response:
-        response += char
-        yield response
-        # Small delay to simulate streaming
-        import time
-        time.sleep(0.01)
+    # Use the new orchestrator function
+    for messages in stream_fed_agent_response(message, api_key, PROMPT_LIBRARY, fed_tools):
+        yield messages
 
 def get_fomc_meetings_sidebar():
     """Generate sidebar content with FOMC meeting details"""
@@ -428,14 +459,15 @@ with gr.Blocks(css=custom_css, title="Fed AI Savant", theme=gr.themes.Soft()) as
 
             chat_interface = gr.ChatInterface(
                 fn=respond_for_chat_interface,
-                chatbot=gr.Chatbot(height=200, show_label=False),
+                type="messages",
+                chatbot=gr.Chatbot(height=500, show_label=False),
                 textbox=gr.Textbox(placeholder="Ask about Fed policy, rate decisions, or FOMC meetings...", scale=10),
                 examples=[
-                    "What was the rate decision in the last FOMC meeting?"
+                    "What was the rate decision in the last FOMC meeting?",
                     "Compare June 2024 vs July 2024 FOMC meetings",
                     "Tell me about inflation expectations",
                     "Has the Fed's employment stance changed?",
-                    "What was the rate decision in the last FOMC meeting?",
+                    "What factors influenced the latest rate decision?",
                 ],
                 submit_btn="Send",
             )

src/modules/fed_tools.py

@@ -13,7 +13,6 @@ def _load_meetings_data() -> List[Dict[str, Any]]:
         if MEETINGS_FILE.exists():
             with open(MEETINGS_FILE, 'r', encoding='utf-8') as f:
                 data = json.load(f)
-            # Sort meetings by date (newest first)
             return sorted(data, key=lambda x: x.get('date', ''), reverse=True)
         else:
             return []
@@ -53,7 +52,6 @@ def search_meetings(query: str, limit: int = 3) -> Dict[str, Any]:
         score = 0
         matched_fields = []
         
-        # Search in various fields and assign scores based on relevance
         search_fields = {
             'date': 2,
             'title': 1,
@@ -82,7 +80,6 @@ def search_meetings(query: str, limit: int = 3) -> Dict[str, Any]:
                 'matched_fields': matched_fields
             })
     
-    # Sort by score (highest first) and limit results
     scored_meetings.sort(key=lambda x: x['score'], reverse=True)
     top_results = scored_meetings[:limit]
     
@@ -117,14 +114,12 @@ def get_rate_decision(date: str) -> Dict[str, Any]:
             "error": "No meetings data available"
         }
     
-    # Find meeting by exact date match
     target_meeting = None
     for meeting in meetings_data:
         if meeting.get('date') == date:
             target_meeting = meeting
             break
     
-    # If no exact match, try to find closest date within 30 days
     if not target_meeting and date:
         try:
             target_date = datetime.strptime(date, '%Y-%m-%d')

src/modules/llm_completions.py

@@ -1,12 +1,18 @@
 from fireworks import LLM
 from pydantic import BaseModel
 import asyncio
+import json
+import time
+from typing import Dict, Any, List
+from gradio import ChatMessage
 
 MODELS = {
     "small": "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507",
     "large": "accounts/fireworks/models/kimi-k2-instruct"
 }
 
+TODAY = time.strftime("%Y-%m-%d")
+
 semaphore = asyncio.Semaphore(10)
 
 def get_llm(model: str, api_key: str) -> LLM:
@@ -39,6 +45,44 @@ async def get_llm_completion(llm: LLM, prompt_text: str, output_class: BaseModel
     )
 
 
+async def get_streaming_completion(llm: LLM, prompt_text: str, system_prompt: str = None):
+    """
+    Get streaming completion from LLM for real-time responses
+    
+    :param llm: The LLM instance
+    :param prompt_text: The user's input message
+    :param system_prompt: Optional system prompt for context
+    :return: Generator yielding response chunks
+    """
+    messages = []
+    
+    if system_prompt:
+        messages.append({
+            "role": "system", 
+            "content": system_prompt
+        })
+    
+    messages.append({
+        "role": "user",
+        "content": prompt_text
+    })
+    
+    try:
+        response = llm.chat.completions.create(
+            messages=messages,
+            temperature=0.2,
+            stream=True,
+            max_tokens=1000
+        )
+        
+        for chunk in response:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+                
+    except Exception as e:
+        yield f"Error generating response: {str(e)}"
+
+
 async def run_multi_llm_completions(llm: LLM, prompts: list[str], output_class: BaseModel) -> list[str]:
     """
     Run multiple LLM completions in parallel
@@ -65,3 +109,190 @@ async def run_multi_llm_completions(llm: LLM, prompts: list[str], output_class:
             ]
     return await asyncio.gather(*tasks)
 
+def get_orchestrator_decision(user_query: str, api_key: str, prompt_library: Dict[str, str]) -> Dict[str, Any]:
+    """Use orchestrator LLM to decide which tools to use"""
+    try:
+        orchestrator_prompt = prompt_library.get('fed_orchestrator', '')
+        formatted_prompt = orchestrator_prompt.format(user_query=user_query, date=TODAY)
+        
+        llm = get_llm("large", api_key)
+        
+        response = llm.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a tool orchestrator. Always respond with valid JSON."},
+                {"role": "user", "content": formatted_prompt}
+            ],
+            temperature=0.1,
+            max_tokens=500
+        )
+        
+        # Parse JSON response
+        result = json.loads(response.choices[0].message.content)
+        return {"success": True, "decision": result}
+        
+    except Exception as e:
+        print(f"Error in orchestrator: {e}")
+        # Fallback to simple logic
+        return {
+            "success": False,
+            "decision": {
+                "tools_needed": [{"function": "get_latest_meeting", "parameters": {}, "reasoning": "Fallback to latest meeting"}],
+                "query_analysis": f"Error occurred, using fallback for: {user_query}"
+            }
+        }
+
+def execute_fed_tools(tools_decision: Dict[str, Any], fed_tools: Dict[str, callable]) -> List[Dict[str, Any]]:
+    """Execute the tools determined by the orchestrator"""
+    results = []
+    
+    for tool in tools_decision.get("tools_needed", []):
+        function_name = tool.get("function", "")
+        parameters = tool.get("parameters", {})
+        reasoning = tool.get("reasoning", "")
+        
+        start_time = time.time()
+        
+        try:
+            # Execute the appropriate function
+            if function_name in fed_tools:
+                tool_func = fed_tools[function_name]
+                result = tool_func(**parameters)
+            else:
+                result = {"success": False, "error": f"Unknown function: {function_name}"}
+            
+            execution_time = time.time() - start_time
+            
+            results.append({
+                "function": function_name,
+                "parameters": parameters,
+                "reasoning": reasoning,
+                "result": result,
+                "execution_time": execution_time,
+                "success": result.get("success", False)
+            })
+            
+        except Exception as e:
+            execution_time = time.time() - start_time
+            results.append({
+                "function": function_name,
+                "parameters": parameters,
+                "reasoning": reasoning,
+                "result": {"success": False, "error": str(e)},
+                "execution_time": execution_time,
+                "success": False
+            })
+    
+    return results
+
+def stream_fed_agent_response(
+    message: str, 
+    api_key: str, 
+    prompt_library: Dict[str, str],
+    fed_tools: Dict[str, callable]
+):
+    """Main orchestrator function that coordinates tools and generates responses with ChatMessage objects"""
+    
+    if not message.strip():
+        yield [ChatMessage(role="assistant", content="Please enter a question about Federal Reserve policy or FOMC meetings.")]
+        return
+    
+    if not api_key.strip():
+        yield [ChatMessage(role="assistant", content="❌ Please set your FIREWORKS_API_KEY environment variable.")]
+        return
+    
+    messages = []
+    
+    try:
+        # Step 1: Use orchestrator to determine tools needed
+        messages.append(ChatMessage(
+            role="assistant", 
+            content="Analyzing your query...",
+            metadata={"title": "🧠 Planning", "status": "pending"}
+        ))
+        yield messages
+        
+        orchestrator_result = get_orchestrator_decision(message, api_key, prompt_library)
+        tools_decision = orchestrator_result["decision"]
+        
+        # Update planning message
+        messages[0] = ChatMessage(
+            role="assistant",
+            content=f"Query Analysis: {tools_decision.get('query_analysis', 'Analyzing Fed data requirements')}\n\nTools needed: {len(tools_decision.get('tools_needed', []))}",
+            metadata={"title": "🧠 Planning", "status": "done"}
+        )
+        yield messages
+        
+        # Step 2: Execute the determined tools
+        if tools_decision.get("tools_needed"):
+            for i, tool in enumerate(tools_decision["tools_needed"]):
+                tool_msg = ChatMessage(
+                    role="assistant",
+                    content=f"Executing: {tool['function']}({', '.join([f'{k}={v}' for k, v in tool['parameters'].items()])})\n\nReasoning: {tool['reasoning']}",
+                    metadata={"title": f"🔧 Tool {i+1}: {tool['function']}", "status": "pending"}
+                )
+                messages.append(tool_msg)
+                yield messages
+            
+            # Execute all tools
+            tool_results = execute_fed_tools(tools_decision, fed_tools)
+            
+            # Update tool messages with results
+            for i, (tool_result, tool_msg) in enumerate(zip(tool_results, messages[1:])):
+                execution_time = tool_result["execution_time"]
+                success_status = "✅" if tool_result["success"] else "❌"
+                
+                messages[i+1] = ChatMessage(
+                    role="assistant",
+                    content=f"{success_status} {tool_result['function']} completed\n\nExecution time: {execution_time:.2f}s\n\nResult summary: {str(tool_result['result'])[:200]}...",
+                    metadata={"title": f"🔧 Tool {i+1}: {tool_result['function']}", "status": "done", "duration": execution_time}
+                )
+            
+            yield messages
+            
+            # Step 3: Use results to generate final response
+            combined_context = ""
+            for result in tool_results:
+                if result["success"]:
+                    combined_context += f"\n\nFrom {result['function']}: {json.dumps(result['result'], indent=2)}"
+            
+            # Generate Fed Savant response using tool results
+            system_prompt_template = prompt_library.get('fed_savant_chat', '')
+            system_prompt = system_prompt_template.format(
+                fed_data_context=combined_context,
+                user_question=message,
+                date=TODAY
+            )
+            
+            # Initialize LLM and get streaming response
+            llm = get_llm("large", api_key)
+            
+            final_response = ""
+            for chunk in llm.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": message}
+                ],
+                temperature=0.2,
+                stream=True,
+                max_tokens=1000
+            ):
+                if chunk.choices[0].delta.content:
+                    final_response += chunk.choices[0].delta.content
+                    
+                    # Update messages list with current response
+                    if len(messages) > len(tool_results):
+                        messages[-1] = ChatMessage(role="assistant", content=final_response)
+                    else:
+                        messages.append(ChatMessage(role="assistant", content=final_response))
+                    
+                    yield messages
+        
+        else:
+            # No tools needed, direct response
+            messages.append(ChatMessage(role="assistant", content="No specific tools required. Providing general Fed information."))
+            yield messages
+                
+    except Exception as e:
+        messages.append(ChatMessage(role="assistant", content=f"Error generating response: {str(e)}"))
+        yield messages
+