clean code

agents/agent_builder.py

@@ -1,62 +0,0 @@
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
-from tools.tools import search_news_tool, fetch_earnings_tool, fetch_market_snapshot_tool
-
-def build_agent(llm, tools, system_instructions: str) -> AgentExecutor:
-    """Create a tool-calling agent with a focused system prompt."""
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            ("system", system_instructions),
-          #  MessagesPlaceholder("chat_history"),
-            ("human", "{input}"),
-              MessagesPlaceholder("agent_scratchpad"),
-        ]
-    )
-    agent = create_tool_calling_agent(llm=llm, tools=tools, prompt=prompt)
-    return AgentExecutor(agent=agent, tools=tools, verbose=False, handle_parsing_errors=True)
-
-
-def make_news_agent(model) -> AgentExecutor:
-    sys = (
-        "You are a News Analyst. Use the search tool to gather 5-8 recent, credible items. "
-        "Synthesize themes, risks, catalysts, and sentiment for investors. Output a concise "
-        "markdown summary with bullet points and 1-2 short citations (URLs)."
-    )
-    return build_agent(model, [search_news_tool], sys)
-
-
-def make_earnings_agent(model) -> AgentExecutor:
-    sys = (
-        "You are an Earnings Analyst. Use the earnings tool to summarize the latest and upcoming "
-        "earnings information (dates, surprises if available) and key line items. Provide a "
-        "short view on momentum and watchouts. Output concise markdown."
-    )
-    return build_agent(model, [fetch_earnings_tool], sys)
-
-
-def make_market_agent(model) -> AgentExecutor:
-    sys = (
-        "You are a Market & Valuation Analyst. Use the market snapshot tool to extract current "
-        "trading context and discuss short-term technicals/flow and high-level valuation notes. "
-        "Output concise markdown."
-    )
-    return build_agent(model, [fetch_market_snapshot_tool], sys)
-
-
-def make_synthesizer(model):
-    """Final writer to merge all agent outputs into actionable recommendations."""
-    template = ChatPromptTemplate.from_messages(
-        [
-            ("system",
-             "You are the Lead Portfolio Analyst. Merge inputs from News, Earnings, and Market agents. "
-             "Produce a final, actionable recommendation block (Buy/Hold/Sell with confidence 0-1), "
-             "key drivers (bull/bear), near-term catalysts, and 2-3 risks. Be concise and concrete."),
-            ("human",
-             "Ticker: {ticker}\n\n"
-             "### News Summary\n{news_summary}\n\n"
-             "### Earnings Summary\n{earnings_summary}\n\n"
-             "### Market Summary\n{market_summary}\n\n"
-             "Write the final recommendation now.")
-        ]
-    )
-    return template | model  # LC chain: Prompt -> LLM

agents/build_graph.py

@@ -1,57 +0,0 @@
-import os
-from langgraph.graph import StateGraph, END
-from agents.agent_builder import make_synthesizer
-from agents.earnings_agent.earnings_agent import create_earnings_agent
-from workflow.graph_state import GraphState
-from langchain_openai import ChatOpenAI
-
-from agents.market_agent.market_agent import create_market_agent
-from agents.news_agent.news_agent import create_news_agent
-from workflow.nodes.nodes import supervisor_node, news_node, earnings_node, market_node, synth_node, AGENTS
-
-
-def build_graph(llm_model_name: str = "gpt-4o-mini"):
-
-    # --- Base LLM for agents & synthesizer (swap to your provider as needed) ---
-    openai_api_key=os.getenv("openai_api_key")
-    llm = ChatOpenAI(api_key=openai_api_key,model=llm_model_name, temperature=0)
-
-    # --- Create specialized agents ---
-    news_agent = create_news_agent(llm)
-    earnings_agent = create_earnings_agent(llm)
-    market_agent = create_market_agent(llm)
-
-    # --- Create synthesizer chain ---
-    synthesizer = make_synthesizer(llm)
-
-    # --- LangGraph: wire nodes ---
-    g = StateGraph(GraphState)
-
-    # Bind node callables with their dependencies via closures
-    g.add_node("news", lambda s: news_node(s, news_agent))
-    g.add_node("earnings", lambda s: earnings_node(s, earnings_agent))
-    g.add_node("market", lambda s: market_node(s, market_agent))
-    g.add_node("synth", lambda s: synth_node(s, synthesizer))
-
-    # Supervisor node
-    g.add_node("supervisor", supervisor_node)
-    # Edges: start -> supervisor -> (news|earnings|market|synth) -> supervisor ... -> synth -> END
-    g.set_entry_point("supervisor")
-    
-    for a in AGENTS:
-        g.add_edge(a, "supervisor")
-    g.add_edge("synth", END)
-
-    # Route decisions come from the router function (returns a string)
-    g.add_conditional_edges(
-        "supervisor",
-        supervisor_router,   # returns: "news" | "earnings" | "market" | "synth"
-        {
-            "news": "news",
-            "earnings": "earnings",
-            "market": "market",
-            "synth": "synth",
-        },
-    )
-
-    return g.compile()

main.py

@@ -1,8 +1,7 @@
-from agents.build_graph import build_graph
 from workflow.agents_workflow import build_agents_workflow
 from workflow.graph_state import GraphState
 
-# Run locally
+# Run locally without gradio
 
 app = build_agents_workflow(llm_model_name="gpt-4o-mini")
 
@@ -19,8 +18,6 @@ def run_user_query(ticker):
     }
     final_state = app.invoke(init_state)
 
-    # Update the Gradio chat history
-
     return final_state
 
 state = run_user_query("AAPL")

tools/tools.py

@@ -1,112 +0,0 @@
-from langchain.tools import tool
-import yfinance as yf
-import datetime as dt
-try:
-    from duckduckgo_search import DDGS
-except Exception:
-    DDGS = None  # optional; handle gracefully below
-
-@tool("search_news", return_direct=False)
-def search_news_tool(query: str, max_results: int = 5) -> str:
-    """
-    Search latest headlines & snippets relevant to a stock or topic.
-    Uses duckduckgo_search as a simple public news proxy.
-    Returns a concise, newline-separated list of 'title — url'.
-    """
-    if DDGS is None:
-        return ("duckduckgo_search not installed. "
-                "Install with `pip install duckduckgo-search` "
-                "or replace this tool with your news API.")
-    items = []
-    with DDGS() as ddgs:
-        for r in ddgs.news(query, timelimit="7d", max_results=max_results):
-            title = r.get("title", "")[:160]
-            url = r.get("url", "")
-            if title and url:
-                items.append(f"{title} — {url}")
-    if not items:
-        return "No recent news found."
-    return "\n".join(items)
-
-
-@tool("fetch_earnings", return_direct=False)
-def fetch_earnings_tool(ticker: str) -> str:
-    """
-    Fetch upcoming and recent earnings info via yfinance.
-    Returns a concise summary (dates + surprises if available).
-    """
-    tk = yf.Ticker(ticker)
-    lines = [f"EARNINGS SNAPSHOT for {ticker.upper()}"]
-
-    # Upcoming earnings (earnings_dates includes future dates)
-    try:
-        ed = tk.earnings_dates  # DataFrame if available
-        if ed is not None and not ed.empty:
-            # Take the next upcoming date and last reported
-            ed_sorted = ed.sort_index()
-            upcoming = ed_sorted[ed_sorted.index >= dt.datetime.now().date()]
-            last = ed_sorted[ed_sorted.index < dt.datetime.now().date()]
-            if not upcoming.empty:
-                lines.append(f"Upcoming: {upcoming.index[0].strftime('%Y-%m-%d')}")
-            if not last.empty:
-                # Try EPS surprise columns if present
-                row = last.iloc[-1]
-                surprise = None
-                for k in ["EPS Surprise %", "Surprise(%)", "epssurprisepct", "epssurprisepercent"]:
-                    if k in row and row[k] is not None:
-                        surprise = row[k]
-                        break
-                lines.append(
-                    f"Last reported: {last.index[-1].strftime('%Y-%m-%d')}"
-                    + (f", EPS surprise: {surprise}" if surprise is not None else "")
-                )
-        else:
-            lines.append("No earnings_dates available.")
-    except Exception as e:
-        lines.append(f"earnings_dates unavailable: {e}")
-
-    # Quarterly financials (very high-level)
-    try:
-        qf = tk.quarterly_financials
-        if qf is not None and not qf.empty:
-            cols = list(qf.columns)
-            if cols:
-                last_q = cols[0]
-                revenue = qf.loc["Total Revenue", last_q] if "Total Revenue" in qf.index else None
-                gross_profit = qf.loc["Gross Profit", last_q] if "Gross Profit" in qf.index else None
-                lines.append(f"Last quarter ({last_q.date()}): Revenue={revenue}, GrossProfit={gross_profit}")
-    except Exception:
-        pass
-
-    return "\n".join(lines)
-
-
-@tool("fetch_market_snapshot", return_direct=False)
-def fetch_market_snapshot_tool(ticker: str) -> str:
-    """
-    Pulls basic market snapshot with yfinance: price, change, volume, valuation.
-    Returns a compact textual snapshot.
-    """
-    tk = yf.Ticker(ticker)
-    info = {}
-    try:
-        price = tk.fast_info.last_price
-        prev_close = tk.fast_info.previous_close
-        change = None
-        if price is not None and prev_close:
-            change = (price - prev_close) / prev_close * 100
-        info.update({
-            "price": price, "prev_close": prev_close, "pct_change": change,
-            "market_cap": tk.fast_info.market_cap, "volume": tk.fast_info.last_volume,
-            "currency": tk.fast_info.currency
-        })
-    except Exception as e:
-        return f"Market snapshot failed: {e}"
-
-    lines = [f"MARKET SNAPSHOT for {ticker.upper()}"]
-    lines.append(f"Price: {info.get('price')} {info.get('currency')}")
-    if info.get("pct_change") is not None:
-        lines.append(f"Day change: {info['pct_change']:.2f}%")
-    lines.append(f"Market Cap: {info.get('market_cap')}")
-    lines.append(f"Volume: {info.get('volume')}")
-    return "\n".join(lines)