Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+accounts.db filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,6 @@
 ---
-title: MCP TradingAgents
-emoji: 📈
-colorFrom: gray
-colorTo: blue
-sdk: gradio
-sdk_version: 5.43.1
+title: MCP_TradingAgents
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.42.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

accounts.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dd78c0461a4717cb42ffcbe55365a3a585948eda79e17e3a69fc65f663d03dd
+size 241664

accounts.py

@@ -0,0 +1,186 @@
+from pydantic import BaseModel
+import json
+from dotenv import load_dotenv
+from datetime import datetime
+from market import get_share_price
+from database import write_account, read_account, write_log
+
+load_dotenv(override=True)
+
+INITIAL_BALANCE = 10_000.0
+SPREAD = 0.002
+
+
+class Transaction(BaseModel):
+    symbol: str
+    quantity: int
+    price: float
+    timestamp: str
+    rationale: str
+
+    def total(self) -> float:
+        return self.quantity * self.price
+    
+    def __repr__(self):
+        return f"{abs(self.quantity)} shares of {self.symbol} at {self.price} each."
+
+
+class Account(BaseModel):
+    name: str
+    balance: float
+    strategy: str
+    holdings: dict[str, int]
+    transactions: list[Transaction]
+    portfolio_value_time_series: list[tuple[str, float]]
+
+    @classmethod
+    def get(cls, name: str):
+        fields = read_account(name.lower())
+        if not fields:
+            fields = {
+                "name": name.lower(),
+                "balance": INITIAL_BALANCE,
+                "strategy": "",
+                "holdings": {},
+                "transactions": [],
+                "portfolio_value_time_series": []
+            }
+            write_account(name, fields)
+        return cls(**fields)
+    
+    
+    def save(self):
+        write_account(self.name.lower(), self.model_dump())
+
+    def reset(self, strategy: str):
+        self.balance = INITIAL_BALANCE
+        self.strategy = strategy
+        self.holdings = {}
+        self.transactions = []
+        self.portfolio_value_time_series = []
+        self.save()
+
+    def deposit(self, amount: float):
+        """ Deposit funds into the account. """
+        if amount <= 0:
+            raise ValueError("Deposit amount must be positive.")
+        self.balance += amount
+        print(f"Deposited ${amount}. New balance: ${self.balance}")
+        self.save()
+
+    def withdraw(self, amount: float):
+        """ Withdraw funds from the account, ensuring it doesn't go negative. """
+        if amount > self.balance:
+            raise ValueError("Insufficient funds for withdrawal.")
+        self.balance -= amount
+        print(f"Withdrew ${amount}. New balance: ${self.balance}")
+        self.save()
+
+    def buy_shares(self, symbol: str, quantity: int, rationale: str) -> str:
+        """ Buy shares of a stock if sufficient funds are available. """
+        price = get_share_price(symbol)
+        buy_price = price * (1 + SPREAD)
+        total_cost = buy_price * quantity
+        
+        if total_cost > self.balance:
+            raise ValueError("Insufficient funds to buy shares.")
+        elif price==0:
+            raise ValueError(f"Unrecognized symbol {symbol}")
+        
+        # Update holdings
+        self.holdings[symbol] = self.holdings.get(symbol, 0) + quantity
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        # Record transaction
+        transaction = Transaction(symbol=symbol, quantity=quantity, price=buy_price, timestamp=timestamp, rationale=rationale)
+        self.transactions.append(transaction)
+        
+        # Update balance
+        self.balance -= total_cost
+        self.save()
+        write_log(self.name, "account", f"Bought {quantity} of {symbol}")
+        return "Completed. Latest details:\n" + self.report()
+
+    def sell_shares(self, symbol: str, quantity: int, rationale: str) -> str:
+        """ Sell shares of a stock if the user has enough shares. """
+        if self.holdings.get(symbol, 0) < quantity:
+            raise ValueError(f"Cannot sell {quantity} shares of {symbol}. Not enough shares held.")
+        
+        price = get_share_price(symbol)
+        sell_price = price * (1 - SPREAD)
+        total_proceeds = sell_price * quantity
+        
+        # Update holdings
+        self.holdings[symbol] -= quantity
+        
+        # If shares are completely sold, remove from holdings
+        if self.holdings[symbol] == 0:
+            del self.holdings[symbol]
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        # Record transaction
+        transaction = Transaction(symbol=symbol, quantity=-quantity, price=sell_price, timestamp=timestamp, rationale=rationale)  # negative quantity for sell
+        self.transactions.append(transaction)
+
+        # Update balance
+        self.balance += total_proceeds
+        self.save()
+        write_log(self.name, "account", f"Sold {quantity} of {symbol}")
+        return "Completed. Latest details:\n" + self.report()
+
+    def calculate_portfolio_value(self):
+        """ Calculate the total value of the user's portfolio. """
+        total_value = self.balance
+        for symbol, quantity in self.holdings.items():
+            total_value += get_share_price(symbol) * quantity
+        return total_value
+
+    def calculate_profit_loss(self, portfolio_value: float):
+        """ Calculate profit or loss from the initial spend. """
+        initial_spend = sum(transaction.total() for transaction in self.transactions)
+        return portfolio_value - initial_spend - self.balance
+
+    def get_holdings(self):
+        """ Report the current holdings of the user. """
+        return self.holdings
+
+    def get_profit_loss(self):
+        """ Report the user's profit or loss at any point in time. """
+        return self.calculate_profit_loss()
+
+    def list_transactions(self):
+        """ List all transactions made by the user. """
+        return [transaction.model_dump() for transaction in self.transactions]
+    
+    def report(self) -> str:
+        """ Return a json string representing the account.  """
+        portfolio_value = self.calculate_portfolio_value()
+        self.portfolio_value_time_series.append((datetime.now().strftime("%Y-%m-%d %H:%M:%S"), portfolio_value))
+        self.save()
+        pnl = self.calculate_profit_loss(portfolio_value)
+        data = self.model_dump()
+        data["total_portfolio_value"] = portfolio_value
+        data["total_profit_loss"] = pnl
+        write_log(self.name, "account", f"Retrieved account details")
+        return json.dumps(data)
+    
+    def get_strategy(self) -> str:
+        """ Return the strategy of the account """
+        write_log(self.name, "account", f"Retrieved strategy")
+        return self.strategy
+    
+    def change_strategy(self, strategy: str) -> str:
+        """ At your discretion, if you choose to, call this to change your investment strategy for the future """
+        self.strategy = strategy
+        self.save()
+        write_log(self.name, "account", f"Changed strategy")
+        return "Changed strategy"
+
+# Example of usage:
+if __name__ == "__main__":
+    account = Account("John Doe")
+    account.deposit(1000)
+    account.buy_shares("AAPL", 5)
+    account.sell_shares("AAPL", 2)
+    print(f"Current Holdings: {account.get_holdings()}")
+    print(f"Total Portfolio Value: {account.calculate_portfolio_value()}")
+    print(f"Profit/Loss: {account.get_profit_loss()}")
+    print(f"Transactions: {account.list_transactions()}")

accounts_client.py

@@ -0,0 +1,50 @@
+import mcp
+from mcp.client.stdio import stdio_client
+from mcp import StdioServerParameters
+from agents import FunctionTool
+import json
+
+params = StdioServerParameters(command="uv", args=["run", "accounts_server.py"], env=None)
+
+
+async def list_accounts_tools():
+    async with stdio_client(params) as streams:
+        async with mcp.ClientSession(*streams) as session:
+            await session.initialize()
+            tools_result = await session.list_tools()
+            return tools_result.tools
+        
+async def call_accounts_tool(tool_name, tool_args):
+    async with stdio_client(params) as streams:
+        async with mcp.ClientSession(*streams) as session:
+            await session.initialize()
+            result = await session.call_tool(tool_name, tool_args)
+            return result
+            
+async def read_accounts_resource(name):
+    async with stdio_client(params) as streams:
+        async with mcp.ClientSession(*streams) as session:
+            await session.initialize()
+            result = await session.read_resource(f"accounts://accounts_server/{name}")
+            return result.contents[0].text
+        
+async def read_strategy_resource(name):
+    async with stdio_client(params) as streams:
+        async with mcp.ClientSession(*streams) as session:
+            await session.initialize()
+            result = await session.read_resource(f"accounts://strategy/{name}")
+            return result.contents[0].text
+
+async def get_accounts_tools_openai():
+    openai_tools = []
+    for tool in await list_accounts_tools():
+        schema = {**tool.inputSchema, "additionalProperties": False}
+        openai_tool = FunctionTool(
+            name=tool.name,
+            description=tool.description,
+            params_json_schema=schema,
+            on_invoke_tool=lambda ctx, args, toolname=tool.name: call_accounts_tool(toolname, json.loads(args))
+                
+        )
+        openai_tools.append(openai_tool)
+    return openai_tools

accounts_server.py

@@ -0,0 +1,70 @@
+from mcp.server.fastmcp import FastMCP
+from accounts import Account
+
+mcp = FastMCP("accounts_server")
+
+@mcp.tool()
+async def get_balance(name: str) -> float:
+    """Get the cash balance of the given account name.
+
+    Args:
+        name: The name of the account holder
+    """
+    return Account.get(name).balance
+
+@mcp.tool()
+async def get_holdings(name: str) -> dict[str, int]:
+    """Get the holdings of the given account name.
+
+    Args:
+        name: The name of the account holder
+    """
+    return Account.get(name).holdings
+
+@mcp.tool()
+async def buy_shares(name: str, symbol: str, quantity: int, rationale: str) -> float:
+    """Buy shares of a stock.
+
+    Args:
+        name: The name of the account holder
+        symbol: The symbol of the stock
+        quantity: The quantity of shares to buy
+        rationale: The rationale for the purchase and fit with the account's strategy
+    """
+    return Account.get(name).buy_shares(symbol, quantity, rationale)
+
+
+@mcp.tool()
+async def sell_shares(name: str, symbol: str, quantity: int, rationale: str) -> float:
+    """Sell shares of a stock.
+
+    Args:
+        name: The name of the account holder
+        symbol: The symbol of the stock
+        quantity: The quantity of shares to sell
+        rationale: The rationale for the sale and fit with the account's strategy
+    """
+    return Account.get(name).sell_shares(symbol, quantity, rationale)
+
+@mcp.tool()
+async def change_strategy(name: str, strategy: str) -> str:
+    """At your discretion, if you choose to, call this to change your investment strategy for the future.
+
+    Args:
+        name: The name of the account holder
+        strategy: The new strategy for the account
+    """
+    return Account.get(name).change_strategy(strategy)
+
+@mcp.resource("accounts://accounts_server/{name}")
+async def read_account_resource(name: str) -> str:
+    account = Account.get(name.lower())
+    return account.report()
+
+@mcp.resource("accounts://strategy/{name}")
+async def read_strategy_resource(name: str) -> str:
+    account = Account.get(name.lower())
+    return account.get_strategy()
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

app.py

@@ -0,0 +1,190 @@
+import gradio as gr
+from util import css, js, Color
+import pandas as pd
+from trading_floor import names, lastnames, short_model_names
+import plotly.express as px
+from accounts import Account
+from database import read_log
+
+mapper = {
+    "trace": Color.WHITE,
+    "agent": Color.CYAN,
+    "function": Color.GREEN,
+    "generation": Color.YELLOW,
+    "response": Color.MAGENTA,
+    "account": Color.RED,
+}
+
+
+class Trader:
+    def __init__(self, name: str, lastname: str, model_name: str):
+        self.name = name
+        self.lastname = lastname
+        self.model_name = model_name
+        self.account = Account.get(name)
+
+    def reload(self):
+        self.account = Account.get(self.name)
+
+    def get_title(self) -> str:
+        return f"<div style='text-align: center;font-size:34px;'>{self.name}<span style='color:#ccc;font-size:24px;'> ({self.model_name}) - {self.lastname}</span></div>"
+
+    def get_strategy(self) -> str:
+        return self.account.get_strategy()
+
+    def get_portfolio_value_df(self) -> pd.DataFrame:
+        df = pd.DataFrame(self.account.portfolio_value_time_series, columns=["datetime", "value"])
+        df["datetime"] = pd.to_datetime(df["datetime"])
+        return df
+
+    def get_portfolio_value_chart(self):
+        df = self.get_portfolio_value_df()
+        fig = px.line(df, x="datetime", y="value")
+        margin = dict(l=40, r=20, t=20, b=40)
+        fig.update_layout(
+            height=300,
+            margin=margin,
+            xaxis_title=None,
+            yaxis_title=None,
+            paper_bgcolor="#bbb",
+            plot_bgcolor="#dde",
+        )
+        fig.update_xaxes(tickformat="%m/%d", tickangle=45, tickfont=dict(size=8))
+        fig.update_yaxes(tickfont=dict(size=8), tickformat=",.0f")
+        return fig
+
+    def get_holdings_df(self) -> pd.DataFrame:
+        """Convert holdings to DataFrame for display"""
+        holdings = self.account.get_holdings()
+        if not holdings:
+            return pd.DataFrame(columns=["Symbol", "Quantity"])
+
+        df = pd.DataFrame(
+            [{"Symbol": symbol, "Quantity": quantity} for symbol, quantity in holdings.items()]
+        )
+        return df
+
+    def get_transactions_df(self) -> pd.DataFrame:
+        """Convert transactions to DataFrame for display"""
+        transactions = self.account.list_transactions()
+        if not transactions:
+            return pd.DataFrame(columns=["Timestamp", "Symbol", "Quantity", "Price", "Rationale"])
+
+        return pd.DataFrame(transactions)
+
+    def get_portfolio_value(self) -> str:
+        """Calculate total portfolio value based on current prices"""
+        portfolio_value = self.account.calculate_portfolio_value() or 0.0
+        pnl = self.account.calculate_profit_loss(portfolio_value) or 0.0
+        color = "green" if pnl >= 0 else "red"
+        emoji = "⬆" if pnl >= 0 else "⬇"
+        return f"<div style='text-align: center;background-color:{color};'><span style='font-size:32px'>${portfolio_value:,.0f}</span><span style='font-size:24px'>&nbsp;&nbsp;&nbsp;{emoji}&nbsp;${pnl:,.0f}</span></div>"
+
+    def get_logs(self, previous=None) -> str:
+        logs = read_log(self.name, last_n=13)
+        response = ""
+        for log in logs:
+            timestamp, type, message = log
+            color = mapper.get(type, Color.WHITE).value
+            response += f"<span style='color:{color}'>{timestamp} : [{type}] {message}</span><br/>"
+        response = f"<div style='height:250px; overflow-y:auto;'>{response}</div>"
+        if response != previous:
+            return response
+        return gr.update()
+
+
+class TraderView:
+    def __init__(self, trader: Trader):
+        self.trader = trader
+        self.portfolio_value = None
+        self.chart = None
+        self.holdings_table = None
+        self.transactions_table = None
+
+    def make_ui(self):
+        with gr.Column():
+            gr.HTML(self.trader.get_title())
+            with gr.Row():
+                self.portfolio_value = gr.HTML(self.trader.get_portfolio_value)
+            with gr.Row():
+                self.chart = gr.Plot(
+                    self.trader.get_portfolio_value_chart, container=True, show_label=False
+                )
+            with gr.Row(variant="panel"):
+                self.log = gr.HTML(self.trader.get_logs)
+            with gr.Row():
+                self.holdings_table = gr.Dataframe(
+                    value=self.trader.get_holdings_df,
+                    label="Holdings",
+                    headers=["Symbol", "Quantity"],
+                    row_count=(5, "dynamic"),
+                    col_count=2,
+                    max_height=300,
+                    elem_classes=["dataframe-fix-small"],
+                )
+            with gr.Row():
+                self.transactions_table = gr.Dataframe(
+                    value=self.trader.get_transactions_df,
+                    label="Recent Transactions",
+                    headers=["Timestamp", "Symbol", "Quantity", "Price", "Rationale"],
+                    row_count=(5, "dynamic"),
+                    col_count=5,
+                    max_height=300,
+                    elem_classes=["dataframe-fix"],
+                )
+
+        timer = gr.Timer(value=120)
+        timer.tick(
+            fn=self.refresh,
+            inputs=[],
+            outputs=[
+                self.portfolio_value,
+                self.chart,
+                self.holdings_table,
+                self.transactions_table,
+            ],
+            show_progress="hidden",
+            queue=False,
+        )
+        log_timer = gr.Timer(value=0.5)
+        log_timer.tick(
+            fn=self.trader.get_logs,
+            inputs=[self.log],
+            outputs=[self.log],
+            show_progress="hidden",
+            queue=False,
+        )
+
+    def refresh(self):
+        self.trader.reload()
+        return (
+            self.trader.get_portfolio_value(),
+            self.trader.get_portfolio_value_chart(),
+            self.trader.get_holdings_df(),
+            self.trader.get_transactions_df(),
+        )
+
+
+# Main UI construction
+def create_ui():
+    """Create the main Gradio UI for the trading simulation"""
+
+    traders = [
+        Trader(trader_name, lastname, model_name)
+        for trader_name, lastname, model_name in zip(names, lastnames, short_model_names)
+    ]
+    trader_views = [TraderView(trader) for trader in traders]
+
+    with gr.Blocks(
+        title="Traders", css=css, js=js, theme=gr.themes.Default(primary_hue="sky"), fill_width=True
+    ) as ui:
+        with gr.Row():
+            for trader_view in trader_views:
+                trader_view.make_ui()
+
+    return ui
+
+
+if __name__ == "__main__":
+    ui = create_ui()
+    ui.launch(inbrowser=True)

database.py

@@ -0,0 +1,101 @@
+import sqlite3
+import json
+from datetime import datetime
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+DB = "accounts.db"
+
+
+with sqlite3.connect(DB) as conn:
+    cursor = conn.cursor()
+    cursor.execute('CREATE TABLE IF NOT EXISTS accounts (name TEXT PRIMARY KEY, account TEXT)')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT,
+            datetime DATETIME,
+            type TEXT,
+            message TEXT
+        )
+    ''')
+    cursor.execute('CREATE TABLE IF NOT EXISTS market (date TEXT PRIMARY KEY, data TEXT)')
+    conn.commit()
+
+def write_account(name, account_dict):
+    json_data = json.dumps(account_dict)
+    with sqlite3.connect(DB) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT INTO accounts (name, account)
+            VALUES (?, ?)
+            ON CONFLICT(name) DO UPDATE SET account=excluded.account
+        ''', (name.lower(), json_data))
+        conn.commit()
+
+def read_account(name):
+    with sqlite3.connect(DB) as conn:
+        cursor = conn.cursor()
+        cursor.execute('SELECT account FROM accounts WHERE name = ?', (name.lower(),))
+        row = cursor.fetchone()
+        return json.loads(row[0]) if row else None
+    
+def write_log(name: str, type: str, message: str):
+    """
+    Write a log entry to the logs table.
+    
+    Args:
+        name (str): The name associated with the log
+        type (str): The type of log entry
+        message (str): The log message
+    """
+    now = datetime.now().isoformat()
+    
+    with sqlite3.connect(DB) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT INTO logs (name, datetime, type, message)
+            VALUES (?, datetime('now'), ?, ?)
+        ''', (name.lower(), type, message))
+        conn.commit()
+
+def read_log(name: str, last_n=10):
+    """
+    Read the most recent log entries for a given name.
+    
+    Args:
+        name (str): The name to retrieve logs for
+        last_n (int): Number of most recent entries to retrieve
+        
+    Returns:
+        list: A list of tuples containing (datetime, type, message)
+    """
+    with sqlite3.connect(DB) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+            SELECT datetime, type, message FROM logs 
+            WHERE name = ? 
+            ORDER BY datetime DESC
+            LIMIT ?
+        ''', (name.lower(), last_n))
+        
+        return reversed(cursor.fetchall())
+
+def write_market(date: str, data: dict) -> None:
+    data_json = json.dumps(data)
+    with sqlite3.connect(DB) as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT INTO market (date, data)
+            VALUES (?, ?)
+            ON CONFLICT(date) DO UPDATE SET data=excluded.data
+        ''', (date, data_json))
+        conn.commit()
+
+def read_market(date: str) -> dict | None:
+    with sqlite3.connect(DB) as conn:
+        cursor = conn.cursor()
+        cursor.execute('SELECT data FROM market WHERE date = ?', (date,))
+        row = cursor.fetchone()
+        return json.loads(row[0]) if row else None

market.py

@@ -0,0 +1,70 @@
+from polygon import RESTClient
+from dotenv import load_dotenv
+import os
+from datetime import datetime
+import random
+from database import write_market, read_market
+from functools import lru_cache
+from datetime import timezone
+
+load_dotenv(override=True)
+
+polygon_api_key = os.getenv("POLYGON_API_KEY")
+polygon_plan = os.getenv("POLYGON_PLAN")
+
+is_paid_polygon = polygon_plan == "paid"
+is_realtime_polygon = polygon_plan == "realtime"
+
+
+def is_market_open() -> bool:
+    client = RESTClient(polygon_api_key)
+    market_status = client.get_market_status()
+    return market_status.market == "open"
+
+
+def get_all_share_prices_polygon_eod() -> dict[str, float]:
+    """With much thanks to student Reema R. for fixing the timezone issue with this!"""
+    client = RESTClient(polygon_api_key)
+
+    probe = client.get_previous_close_agg("SPY")[0]
+    last_close = datetime.fromtimestamp(probe.timestamp / 1000, tz=timezone.utc).date()
+
+    results = client.get_grouped_daily_aggs(last_close, adjusted=True, include_otc=False)
+    return {result.ticker: result.close for result in results}
+
+
+@lru_cache(maxsize=2)
+def get_market_for_prior_date(today):
+    market_data = read_market(today)
+    if not market_data:
+        market_data = get_all_share_prices_polygon_eod()
+        write_market(today, market_data)
+    return market_data
+
+
+def get_share_price_polygon_eod(symbol) -> float:
+    today = datetime.now().date().strftime("%Y-%m-%d")
+    market_data = get_market_for_prior_date(today)
+    return market_data.get(symbol, 0.0)
+
+
+def get_share_price_polygon_min(symbol) -> float:
+    client = RESTClient(polygon_api_key)
+    result = client.get_snapshot_ticker("stocks", symbol)
+    return result.min.close or result.prev_day.close
+
+
+def get_share_price_polygon(symbol) -> float:
+    if is_paid_polygon:
+        return get_share_price_polygon_min(symbol)
+    else:
+        return get_share_price_polygon_eod(symbol)
+
+
+def get_share_price(symbol) -> float:
+    if polygon_api_key:
+        try:
+            return get_share_price_polygon(symbol)
+        except Exception as e:
+            print(f"Was not able to use the polygon API due to {e}; using a random number")
+    return float(random.randint(1, 100))

market_server.py

@@ -0,0 +1,16 @@
+from mcp.server.fastmcp import FastMCP
+from market import get_share_price
+
+mcp = FastMCP("market_server")
+
+@mcp.tool()
+async def lookup_share_price(symbol: str) -> float:
+    """This tool provides the current price of the given stock symbol.
+
+    Args:
+        symbol: the symbol of the stock
+    """
+    return get_share_price(symbol)
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

mcp_params.py

@@ -0,0 +1,46 @@
+import os
+from dotenv import load_dotenv
+from market import is_paid_polygon, is_realtime_polygon
+
+load_dotenv(override=True)
+
+brave_env = {"BRAVE_API_KEY": os.getenv("BRAVE_API_KEY")}
+polygon_api_key = os.getenv("POLYGON_API_KEY")
+
+# The MCP server for the Trader to read Market Data
+
+if is_paid_polygon or is_realtime_polygon:
+    market_mcp = {
+        "command": "uvx",
+        "args": ["--from", "git+https://github.com/polygon-io/mcp_polygon@v0.1.0", "mcp_polygon"],
+        "env": {"POLYGON_API_KEY": polygon_api_key},
+    }
+else:
+    market_mcp = {"command": "uv", "args": ["run", "market_server.py"]}
+
+
+# The full set of MCP servers for the trader: Accounts, Push Notification and the Market
+
+trader_mcp_server_params = [
+    {"command": "uv", "args": ["run", "accounts_server.py"]},
+    {"command": "uv", "args": ["run", "push_server.py"]},
+    market_mcp,
+]
+
+# The full set of MCP servers for the researcher: Fetch, Brave Search and Memory
+
+
+def researcher_mcp_server_params(name: str):
+    return [
+        {"command": "uvx", "args": ["mcp-server-fetch"]},
+        {
+            "command": "npx",
+            "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+            "env": brave_env,
+        },
+        {
+            "command": "npx",
+            "args": ["-y", "mcp-memory-libsql"],
+            "env": {"LIBSQL_URL": f"file:./memory/{name}.db"},
+        },
+    ]

push_server.py

@@ -0,0 +1,31 @@
+import os
+from dotenv import load_dotenv
+import requests
+from pydantic import BaseModel, Field
+from mcp.server.fastmcp import FastMCP
+
+load_dotenv(override=True)
+
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_url = "https://api.pushover.net/1/messages.json"
+
+
+mcp = FastMCP("push_server")
+
+
+class PushModelArgs(BaseModel):
+    message: str = Field(description="A brief message to push")
+
+
+@mcp.tool()
+def push(args: PushModelArgs):
+    """Send a push notification with this brief message"""
+    print(f"Push: {args.message}")
+    payload = {"user": pushover_user, "token": pushover_token, "message": args.message}
+    requests.post(pushover_url, data=payload)
+    return "Push notification sent"
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

requirements.txt

@@ -0,0 +1,10 @@
+openai
+openai-agents
+sendgrid
+pydantic
+requests
+playwright
+dotenv
+python-dotenv
+gradio
+polygon

reset.py

@@ -0,0 +1,50 @@
+from accounts import Account
+
+waren_strategy = """
+You are Warren, and you are named in homage to your role model, Warren Buffett.
+You are a value-oriented investor who prioritizes long-term wealth creation.
+You identify high-quality companies trading below their intrinsic value.
+You invest patiently and hold positions through market fluctuations, 
+relying on meticulous fundamental analysis, steady cash flows, strong management teams, 
+and competitive advantages. You rarely react to short-term market movements, 
+trusting your deep research and value-driven strategy.
+"""
+
+george_strategy = """
+You are George, and you are named in homage to your role model, George Soros.
+You are an aggressive macro trader who actively seeks significant market 
+mispricings. You look for large-scale economic and 
+geopolitical events that create investment opportunities. Your approach is contrarian, 
+willing to bet boldly against prevailing market sentiment when your macroeconomic analysis 
+suggests a significant imbalance. You leverage careful timing and decisive action to 
+capitalize on rapid market shifts.
+"""
+
+ray_strategy = """
+You are Ray, and you are named in homage to your role model, Ray Dalio.
+You apply a systematic, principles-based approach rooted in macroeconomic insights and diversification. 
+You invest broadly across asset classes, utilizing risk parity strategies to achieve balanced returns 
+in varying market environments. You pay close attention to macroeconomic indicators, central bank policies, 
+and economic cycles, adjusting your portfolio strategically to manage risk and preserve capital across diverse market conditions.
+"""
+
+cathie_strategy = """
+You are Cathie, and you are named in homage to your role model, Cathie Wood.
+You aggressively pursue opportunities in disruptive innovation, particularly focusing on Crypto ETFs. 
+Your strategy is to identify and invest boldly in sectors poised to revolutionize the economy, 
+accepting higher volatility for potentially exceptional returns. You closely monitor technological breakthroughs, 
+regulatory changes, and market sentiment in crypto ETFs, ready to take bold positions 
+and actively manage your portfolio to capitalize on rapid growth trends.
+You focus your trading on crypto ETFs.
+"""
+
+
+def reset_traders():
+    Account.get("Warren").reset(waren_strategy)
+    Account.get("George").reset(george_strategy)
+    Account.get("Ray").reset(ray_strategy)
+    Account.get("Cathie").reset(cathie_strategy)
+
+
+if __name__ == "__main__":
+    reset_traders()

templates.py

@@ -0,0 +1,86 @@
+from datetime import datetime
+from market import is_paid_polygon, is_realtime_polygon
+
+if is_realtime_polygon:
+    note = "You have access to realtime market data tools; use your get_last_trade tool for the latest trade price. You can also use tools for share information, trends and technical indicators and fundamentals."
+elif is_paid_polygon:
+    note = "You have access to market data tools but without access to the trade or quote tools; use your get_snapshot_ticker tool to get the latest share price on a 15 min delay. You can also use tools for share information, trends and technical indicators and fundamentals."
+else:
+    note = "You have access to end of day market data; use you get_share_price tool to get the share price as of the prior close."
+
+
+def researcher_instructions():
+    return f"""You are a financial researcher. You are able to search the web for interesting financial news,
+look for possible trading opportunities, and help with research.
+Based on the request, you carry out necessary research and respond with your findings.
+Take time to make multiple searches to get a comprehensive overview, and then summarize your findings.
+If the web search tool raises an error due to rate limits, then use your other tool that fetches web pages instead.
+
+Important: making use of your knowledge graph to retrieve and store information on companies, websites and market conditions:
+
+Make use of your knowledge graph tools to store and recall entity information; use it to retrieve information that
+you have worked on previously, and store new information about companies, stocks and market conditions.
+Also use it to store web addresses that you find interesting so you can check them later.
+Draw on your knowledge graph to build your expertise over time.
+
+If there isn't a specific request, then just respond with investment opportunities based on searching latest news.
+The current datetime is {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+"""
+
+def research_tool():
+    return "This tool researches online for news and opportunities, \
+either based on your specific request to look into a certain stock, \
+or generally for notable financial news and opportunities. \
+Describe what kind of research you're looking for."
+
+def trader_instructions(name: str):
+    return f"""
+You are {name}, a trader on the stock market. Your account is under your name, {name}.
+You actively manage your portfolio according to your strategy.
+You have access to tools including a researcher to research online for news and opportunities, based on your request.
+You also have tools to access to financial data for stocks. {note}
+And you have tools to buy and sell stocks using your account name {name}.
+You can use your entity tools as a persistent memory to store and recall information; you share
+this memory with other traders and can benefit from the group's knowledge.
+Use these tools to carry out research, make decisions, and execute trades.
+After you've completed trading, send a push notification with a brief summary of activity, then reply with a 2-3 sentence appraisal.
+Your goal is to maximize your profits according to your strategy.
+"""
+
+def trade_message(name, strategy, account):
+    return f"""Based on your investment strategy, you should now look for new opportunities.
+Use the research tool to find news and opportunities consistent with your strategy.
+Do not use the 'get company news' tool; use the research tool instead.
+Use the tools to research stock price and other company information. {note}
+Finally, make you decision, then execute trades using the tools.
+Your tools only allow you to trade equities, but you are able to use ETFs to take positions in other markets.
+You do not need to rebalance your portfolio; you will be asked to do so later.
+Just make trades based on your strategy as needed.
+Your investment strategy:
+{strategy}
+Here is your current account:
+{account}
+Here is the current datetime:
+{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+Now, carry out analysis, make your decision and execute trades. Your account name is {name}.
+After you've executed your trades, send a push notification with a brief sumnmary of trades and the health of the portfolio, then
+respond with a brief 2-3 sentence appraisal of your portfolio and its outlook.
+"""
+
+def rebalance_message(name, strategy, account):
+    return f"""Based on your investment strategy, you should now examine your portfolio and decide if you need to rebalance.
+Use the research tool to find news and opportunities affecting your existing portfolio.
+Use the tools to research stock price and other company information affecting your existing portfolio. {note}
+Finally, make you decision, then execute trades using the tools as needed.
+You do not need to identify new investment opportunities at this time; you will be asked to do so later.
+Just rebalance your portfolio based on your strategy as needed.
+Your investment strategy:
+{strategy}
+You also have a tool to change your strategy if you wish; you can decide at any time that you would like to evolve or even switch your strategy.
+Here is your current account:
+{account}
+Here is the current datetime:
+{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+Now, carry out analysis, make your decision and execute trades. Your account name is {name}.
+After you've executed your trades, send a push notification with a brief sumnmary of trades and the health of the portfolio, then
+respond with a brief 2-3 sentence appraisal of your portfolio and its outlook."""

tracers.py

@@ -0,0 +1,75 @@
+from agents import TracingProcessor, Trace, Span
+from database import write_log
+import secrets
+import string
+
+ALPHANUM = string.ascii_lowercase + string.digits 
+
+def make_trace_id(tag: str) -> str:
+    """
+    Return a string of the form 'trace_<tag><random>',
+    where the total length after 'trace_' is 32 chars.
+    """
+    tag += "0"
+    pad_len = 32 - len(tag)
+    random_suffix = ''.join(secrets.choice(ALPHANUM) for _ in range(pad_len))
+    return f"trace_{tag}{random_suffix}"
+
+class LogTracer(TracingProcessor):
+
+    def get_name(self, trace_or_span: Trace | Span) -> str | None:
+        trace_id = trace_or_span.trace_id
+        name = trace_id.split("_")[1]
+        if '0' in name:
+            return name.split("0")[0]
+        else:
+            return None
+
+    def on_trace_start(self, trace) -> None:
+        name = self.get_name(trace)
+        if name:
+            write_log(name, "trace", f"Started: {trace.name}")
+
+    def on_trace_end(self, trace) -> None:
+        name = self.get_name(trace)
+        if name:
+            write_log(name, "trace", f"Ended: {trace.name}")
+
+    def on_span_start(self, span) -> None:
+        name = self.get_name(span)
+        type = span.span_data.type if span.span_data else "span"
+        if name:
+            message = "Started"
+            if span.span_data:
+                if span.span_data.type:
+                    message += f" {span.span_data.type}"
+                if hasattr(span.span_data, "name") and span.span_data.name:
+                    message += f" {span.span_data.name}"
+                if hasattr(span.span_data, "server") and span.span_data.server:
+                    message += f" {span.span_data.server}"
+            if span.error:
+                message += f" {span.error}"
+            write_log(name, type, message)
+
+    def on_span_end(self, span) -> None:
+        name = self.get_name(span)
+        type = span.span_data.type if span.span_data else "span"
+        if name:
+            message = "Ended"
+            if span.span_data:
+                if span.span_data.type:
+                    
+                    message += f" {span.span_data.type}"
+                if hasattr(span.span_data, "name") and span.span_data.name:
+                    message += f" {span.span_data.name}"
+                if hasattr(span.span_data, "server") and span.span_data.server:
+                    message += f" {span.span_data.server}"
+            if span.error:
+                message += f" {span.error}"
+            write_log(name, type, message)
+
+    def force_flush(self) -> None:
+        pass
+
+    def shutdown(self) -> None:
+        pass

traders.py

@@ -0,0 +1,131 @@
+from contextlib import AsyncExitStack
+from accounts_client import read_accounts_resource, read_strategy_resource
+from tracers import make_trace_id
+from agents import Agent, Tool, Runner, OpenAIChatCompletionsModel, trace
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+import os
+import json
+from agents.mcp import MCPServerStdio
+from templates import (
+    researcher_instructions,
+    trader_instructions,
+    trade_message,
+    rebalance_message,
+    research_tool,
+)
+from mcp_params import trader_mcp_server_params, researcher_mcp_server_params
+
+load_dotenv(override=True)
+
+deepseek_api_key = os.getenv("DEEPSEEK_API_KEY")
+google_api_key = os.getenv("GOOGLE_API_KEY")
+grok_api_key = os.getenv("GROK_API_KEY")
+openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+
+DEEPSEEK_BASE_URL = "https://api.deepseek.com/v1"
+GROK_BASE_URL = "https://api.x.ai/v1"
+GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+MAX_TURNS = 30
+
+openrouter_client = AsyncOpenAI(base_url=OPENROUTER_BASE_URL, api_key=openrouter_api_key)
+deepseek_client = AsyncOpenAI(base_url=DEEPSEEK_BASE_URL, api_key=deepseek_api_key)
+grok_client = AsyncOpenAI(base_url=GROK_BASE_URL, api_key=grok_api_key)
+gemini_client = AsyncOpenAI(base_url=GEMINI_BASE_URL, api_key=google_api_key)
+
+
+def get_model(model_name: str):
+    if "/" in model_name:
+        return OpenAIChatCompletionsModel(model=model_name, openai_client=openrouter_client)
+    elif "deepseek" in model_name:
+        return OpenAIChatCompletionsModel(model=model_name, openai_client=deepseek_client)
+    elif "grok" in model_name:
+        return OpenAIChatCompletionsModel(model=model_name, openai_client=grok_client)
+    elif "gemini" in model_name:
+        return OpenAIChatCompletionsModel(model=model_name, openai_client=gemini_client)
+    else:
+        return model_name
+
+
+async def get_researcher(mcp_servers, model_name) -> Agent:
+    researcher = Agent(
+        name="Researcher",
+        instructions=researcher_instructions(),
+        model=get_model(model_name),
+        mcp_servers=mcp_servers,
+    )
+    return researcher
+
+
+async def get_researcher_tool(mcp_servers, model_name) -> Tool:
+    researcher = await get_researcher(mcp_servers, model_name)
+    return researcher.as_tool(tool_name="Researcher", tool_description=research_tool())
+
+
+class Trader:
+    def __init__(self, name: str, lastname="Trader", model_name="gpt-4o-mini"):
+        self.name = name
+        self.lastname = lastname
+        self.agent = None
+        self.model_name = model_name
+        self.do_trade = True
+
+    async def create_agent(self, trader_mcp_servers, researcher_mcp_servers) -> Agent:
+        tool = await get_researcher_tool(researcher_mcp_servers, self.model_name)
+        self.agent = Agent(
+            name=self.name,
+            instructions=trader_instructions(self.name),
+            model=get_model(self.model_name),
+            tools=[tool],
+            mcp_servers=trader_mcp_servers,
+        )
+        return self.agent
+
+    async def get_account_report(self) -> str:
+        account = await read_accounts_resource(self.name)
+        account_json = json.loads(account)
+        account_json.pop("portfolio_value_time_series", None)
+        return json.dumps(account_json)
+
+    async def run_agent(self, trader_mcp_servers, researcher_mcp_servers):
+        self.agent = await self.create_agent(trader_mcp_servers, researcher_mcp_servers)
+        account = await self.get_account_report()
+        strategy = await read_strategy_resource(self.name)
+        message = (
+            trade_message(self.name, strategy, account)
+            if self.do_trade
+            else rebalance_message(self.name, strategy, account)
+        )
+        await Runner.run(self.agent, message, max_turns=MAX_TURNS)
+
+    async def run_with_mcp_servers(self):
+        async with AsyncExitStack() as stack:
+            trader_mcp_servers = [
+                await stack.enter_async_context(
+                    MCPServerStdio(params, client_session_timeout_seconds=120)
+                )
+                for params in trader_mcp_server_params
+            ]
+            async with AsyncExitStack() as stack:
+                researcher_mcp_servers = [
+                    await stack.enter_async_context(
+                        MCPServerStdio(params, client_session_timeout_seconds=120)
+                    )
+                    for params in researcher_mcp_server_params(self.name)
+                ]
+                await self.run_agent(trader_mcp_servers, researcher_mcp_servers)
+
+    async def run_with_trace(self):
+        trace_name = f"{self.name}-trading" if self.do_trade else f"{self.name}-rebalancing"
+        trace_id = make_trace_id(f"{self.name.lower()}")
+        with trace(trace_name, trace_id=trace_id):
+            await self.run_with_mcp_servers()
+
+    async def run(self):
+        try:
+            await self.run_with_trace()
+        except Exception as e:
+            print(f"Error running trader {self.name}: {e}")
+        self.do_trade = not self.do_trade

trading_floor.py

@@ -0,0 +1,54 @@
+from traders import Trader
+from typing import List
+import asyncio
+from tracers import LogTracer
+from agents import add_trace_processor
+from market import is_market_open
+from dotenv import load_dotenv
+import os
+
+load_dotenv(override=True)
+
+RUN_EVERY_N_MINUTES = int(os.getenv("RUN_EVERY_N_MINUTES", "60"))
+RUN_EVEN_WHEN_MARKET_IS_CLOSED = (
+    os.getenv("RUN_EVEN_WHEN_MARKET_IS_CLOSED", "false").strip().lower() == "true"
+)
+USE_MANY_MODELS = os.getenv("USE_MANY_MODELS", "false").strip().lower() == "true"
+
+names = ["Warren", "George", "Ray", "Cathie"]
+lastnames = ["Patience", "Bold", "Systematic", "Crypto"]
+
+if USE_MANY_MODELS:
+    model_names = [
+        "gpt-4.1-mini",
+        "deepseek-chat",
+        "gemini-2.5-flash-preview-04-17",
+        "grok-3-mini-beta",
+    ]
+    short_model_names = ["GPT 4.1 Mini", "DeepSeek V3", "Gemini 2.5 Flash", "Grok 3 Mini"]
+else:
+    model_names = ["gpt-4o-mini"] * 4
+    short_model_names = ["GPT 4o mini"] * 4
+
+
+def create_traders() -> List[Trader]:
+    traders = []
+    for name, lastname, model_name in zip(names, lastnames, model_names):
+        traders.append(Trader(name, lastname, model_name))
+    return traders
+
+
+async def run_every_n_minutes():
+    add_trace_processor(LogTracer())
+    traders = create_traders()
+    while True:
+        if RUN_EVEN_WHEN_MARKET_IS_CLOSED or is_market_open():
+            await asyncio.gather(*[trader.run() for trader in traders])
+        else:
+            print("Market is closed, skipping run")
+        await asyncio.sleep(RUN_EVERY_N_MINUTES * 60)
+
+
+if __name__ == "__main__":
+    print(f"Starting scheduler to run every {RUN_EVERY_N_MINUTES} minutes")
+    asyncio.run(run_every_n_minutes())

util.py

@@ -0,0 +1,50 @@
+from enum import Enum
+
+css = """
+.positive-pnl {
+    color: green !important;
+    font-weight: bold;
+}
+.positive-bg {
+    background-color: green !important;
+    font-weight: bold;
+}
+.negative-bg {
+    background-color: red !important;
+    font-weight: bold;
+}
+.negative-pnl {
+    color: red !important;
+    font-weight: bold;
+}
+.dataframe-fix-small .table-wrap {
+min-height: 150px;
+max-height: 150px;
+}
+.dataframe-fix .table-wrap {
+min-height: 200px;
+max-height: 200px;
+}
+footer{display:none !important}
+"""
+
+
+js = """
+function refresh() {
+    const url = new URL(window.location);
+
+    if (url.searchParams.get('__theme') !== 'dark') {
+        url.searchParams.set('__theme', 'dark');
+        window.location.href = url.href;
+    }
+}
+"""
+
+class Color(Enum):
+    RED = "#dd0000"
+    GREEN = "#00dd00"
+    YELLOW = "#dddd00"
+    BLUE = "#0000ee"
+    MAGENTA = "#aa00dd"
+    CYAN = "#00dddd"
+    WHITE = "#87CEEB"