chore(release): v0.1.0 – initial public release of TradingAgents

tradingagents/agents/utils/agent_states.py

@@ -0,0 +1,76 @@
+from typing import Annotated, Sequence
+from datetime import date, timedelta, datetime
+from typing_extensions import TypedDict, Optional
+from langchain_openai import ChatOpenAI
+from tradingagents.agents import *
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import END, StateGraph, START, MessagesState
+
+
+# Researcher team state
+class InvestDebateState(TypedDict):
+    bull_history: Annotated[
+        str, "Bullish Conversation history"
+    ]  # Bullish Conversation history
+    bear_history: Annotated[
+        str, "Bearish Conversation history"
+    ]  # Bullish Conversation history
+    history: Annotated[str, "Conversation history"]  # Conversation history
+    current_response: Annotated[str, "Latest response"]  # Last response
+    judge_decision: Annotated[str, "Final judge decision"]  # Last response
+    count: Annotated[int, "Length of the current conversation"]  # Conversation length
+
+
+# Risk management team state
+class RiskDebateState(TypedDict):
+    risky_history: Annotated[
+        str, "Risky Agent's Conversation history"
+    ]  # Conversation history
+    safe_history: Annotated[
+        str, "Safe Agent's Conversation history"
+    ]  # Conversation history
+    neutral_history: Annotated[
+        str, "Neutral Agent's Conversation history"
+    ]  # Conversation history
+    history: Annotated[str, "Conversation history"]  # Conversation history
+    latest_speaker: Annotated[str, "Analyst that spoke last"]
+    current_risky_response: Annotated[
+        str, "Latest response by the risky analyst"
+    ]  # Last response
+    current_safe_response: Annotated[
+        str, "Latest response by the safe analyst"
+    ]  # Last response
+    current_neutral_response: Annotated[
+        str, "Latest response by the neutral analyst"
+    ]  # Last response
+    judge_decision: Annotated[str, "Judge's decision"]
+    count: Annotated[int, "Length of the current conversation"]  # Conversation length
+
+
+class AgentState(MessagesState):
+    company_of_interest: Annotated[str, "Company that we are interested in trading"]
+    trade_date: Annotated[str, "What date we are trading at"]
+
+    sender: Annotated[str, "Agent that sent this message"]
+
+    # research step
+    market_report: Annotated[str, "Report from the Market Analyst"]
+    sentiment_report: Annotated[str, "Report from the Social Media Analyst"]
+    news_report: Annotated[
+        str, "Report from the News Researcher of current world affairs"
+    ]
+    fundamentals_report: Annotated[str, "Report from the Fundamentals Researcher"]
+
+    # researcher team discussion step
+    investment_debate_state: Annotated[
+        InvestDebateState, "Current state of the debate on if to invest or not"
+    ]
+    investment_plan: Annotated[str, "Plan generated by the Analyst"]
+
+    trader_investment_plan: Annotated[str, "Plan generated by the Trader"]
+
+    # risk management team discussion step
+    risk_debate_state: Annotated[
+        RiskDebateState, "Current state of the debate on evaluating risk"
+    ]
+    final_trade_decision: Annotated[str, "Final decision made by the Risk Analysts"]

tradingagents/agents/utils/agent_utils.py

@@ -0,0 +1,411 @@
+from langchain_core.messages import BaseMessage, HumanMessage, ToolMessage, AIMessage
+from typing import List
+from typing import Annotated
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.messages import RemoveMessage
+from langchain_core.tools import tool
+from datetime import date, timedelta, datetime
+import functools
+import pandas as pd
+import os
+from dateutil.relativedelta import relativedelta
+from langchain_openai import ChatOpenAI
+import tradingagents.dataflows.interface as interface
+from tradingagents.default_config import DEFAULT_CONFIG
+
+
+def create_msg_delete():
+    def delete_messages(state):
+        """To prevent message history from overflowing, regularly clear message history after a stage of the pipeline is done"""
+        messages = state["messages"]
+        return {"messages": [RemoveMessage(id=m.id) for m in messages]}
+
+    return delete_messages
+
+
+class Toolkit:
+    _config = DEFAULT_CONFIG.copy()
+
+    @classmethod
+    def update_config(cls, config):
+        """Update the class-level configuration."""
+        cls._config.update(config)
+
+    @property
+    def config(self):
+        """Access the configuration."""
+        return self._config
+
+    def __init__(self, config=None):
+        if config:
+            self.update_config(config)
+
+    @staticmethod
+    @tool
+    def get_reddit_news(
+        curr_date: Annotated[str, "Date you want to get news for in yyyy-mm-dd format"],
+    ) -> str:
+        """
+        Retrieve global news from Reddit within a specified time frame.
+        Args:
+            curr_date (str): Date you want to get news for in yyyy-mm-dd format
+        Returns:
+            str: A formatted dataframe containing the latest global news from Reddit in the specified time frame.
+        """
+        
+        global_news_result = interface.get_reddit_global_news(curr_date, 7, 5)
+
+        return global_news_result
+
+    @staticmethod
+    @tool
+    def get_finnhub_news(
+        ticker: Annotated[
+            str,
+            "Search query of a company, e.g. 'AAPL, TSM, etc.",
+        ],
+        start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+        end_date: Annotated[str, "End date in yyyy-mm-dd format"],
+    ):
+        """
+        Retrieve the latest news about a given stock from Finnhub within a date range
+        Args:
+            ticker (str): Ticker of a company. e.g. AAPL, TSM
+            start_date (str): Start date in yyyy-mm-dd format
+            end_date (str): End date in yyyy-mm-dd format
+        Returns:
+            str: A formatted dataframe containing news about the company within the date range from start_date to end_date
+        """
+
+        end_date_str = end_date
+
+        end_date = datetime.strptime(end_date, "%Y-%m-%d")
+        start_date = datetime.strptime(start_date, "%Y-%m-%d")
+        look_back_days = (end_date - start_date).days
+
+        finnhub_news_result = interface.get_finnhub_news(
+            ticker, end_date_str, look_back_days
+        )
+
+        return finnhub_news_result
+
+    @staticmethod
+    @tool
+    def get_reddit_stock_info(
+        ticker: Annotated[
+            str,
+            "Ticker of a company. e.g. AAPL, TSM",
+        ],
+        curr_date: Annotated[str, "Current date you want to get news for"],
+    ) -> str:
+        """
+        Retrieve the latest news about a given stock from Reddit, given the current date.
+        Args:
+            ticker (str): Ticker of a company. e.g. AAPL, TSM
+            curr_date (str): current date in yyyy-mm-dd format to get news for
+        Returns:
+            str: A formatted dataframe containing the latest news about the company on the given date
+        """
+
+        stock_news_results = interface.get_reddit_company_news(ticker, curr_date, 7, 5)
+
+        return stock_news_results
+
+    @staticmethod
+    @tool
+    def get_YFin_data(
+        symbol: Annotated[str, "ticker symbol of the company"],
+        start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+        end_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+    ) -> str:
+        """
+        Retrieve the stock price data for a given ticker symbol from Yahoo Finance.
+        Args:
+            symbol (str): Ticker symbol of the company, e.g. AAPL, TSM
+            start_date (str): Start date in yyyy-mm-dd format
+            end_date (str): End date in yyyy-mm-dd format
+        Returns:
+            str: A formatted dataframe containing the stock price data for the specified ticker symbol in the specified date range.
+        """
+
+        result_data = interface.get_YFin_data(symbol, start_date, end_date)
+
+        return result_data
+
+    @staticmethod
+    @tool
+    def get_YFin_data_online(
+        symbol: Annotated[str, "ticker symbol of the company"],
+        start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+        end_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+    ) -> str:
+        """
+        Retrieve the stock price data for a given ticker symbol from Yahoo Finance.
+        Args:
+            symbol (str): Ticker symbol of the company, e.g. AAPL, TSM
+            start_date (str): Start date in yyyy-mm-dd format
+            end_date (str): End date in yyyy-mm-dd format
+        Returns:
+            str: A formatted dataframe containing the stock price data for the specified ticker symbol in the specified date range.
+        """
+
+        result_data = interface.get_YFin_data_online(symbol, start_date, end_date)
+
+        return result_data
+
+    @staticmethod
+    @tool
+    def get_stockstats_indicators_report(
+        symbol: Annotated[str, "ticker symbol of the company"],
+        indicator: Annotated[
+            str, "technical indicator to get the analysis and report of"
+        ],
+        curr_date: Annotated[
+            str, "The current trading date you are trading on, YYYY-mm-dd"
+        ],
+        look_back_days: Annotated[int, "how many days to look back"] = 30,
+    ) -> str:
+        """
+        Retrieve stock stats indicators for a given ticker symbol and indicator.
+        Args:
+            symbol (str): Ticker symbol of the company, e.g. AAPL, TSM
+            indicator (str): Technical indicator to get the analysis and report of
+            curr_date (str): The current trading date you are trading on, YYYY-mm-dd
+            look_back_days (int): How many days to look back, default is 30
+        Returns:
+            str: A formatted dataframe containing the stock stats indicators for the specified ticker symbol and indicator.
+        """
+
+        result_stockstats = interface.get_stock_stats_indicators_window(
+            symbol, indicator, curr_date, look_back_days, False
+        )
+
+        return result_stockstats
+
+    @staticmethod
+    @tool
+    def get_stockstats_indicators_report_online(
+        symbol: Annotated[str, "ticker symbol of the company"],
+        indicator: Annotated[
+            str, "technical indicator to get the analysis and report of"
+        ],
+        curr_date: Annotated[
+            str, "The current trading date you are trading on, YYYY-mm-dd"
+        ],
+        look_back_days: Annotated[int, "how many days to look back"] = 30,
+    ) -> str:
+        """
+        Retrieve stock stats indicators for a given ticker symbol and indicator.
+        Args:
+            symbol (str): Ticker symbol of the company, e.g. AAPL, TSM
+            indicator (str): Technical indicator to get the analysis and report of
+            curr_date (str): The current trading date you are trading on, YYYY-mm-dd
+            look_back_days (int): How many days to look back, default is 30
+        Returns:
+            str: A formatted dataframe containing the stock stats indicators for the specified ticker symbol and indicator.
+        """
+
+        result_stockstats = interface.get_stock_stats_indicators_window(
+            symbol, indicator, curr_date, look_back_days, True
+        )
+
+        return result_stockstats
+
+    @staticmethod
+    @tool
+    def get_finnhub_company_insider_sentiment(
+        ticker: Annotated[str, "ticker symbol for the company"],
+        curr_date: Annotated[
+            str,
+            "current date of you are trading at, yyyy-mm-dd",
+        ],
+    ):
+        """
+        Retrieve insider sentiment information about a company (retrieved from public SEC information) for the past 30 days
+        Args:
+            ticker (str): ticker symbol of the company
+            curr_date (str): current date you are trading at, yyyy-mm-dd
+        Returns:
+            str: a report of the sentiment in the past 30 days starting at curr_date
+        """
+
+        data_sentiment = interface.get_finnhub_company_insider_sentiment(
+            ticker, curr_date, 30
+        )
+
+        return data_sentiment
+
+    @staticmethod
+    @tool
+    def get_finnhub_company_insider_transactions(
+        ticker: Annotated[str, "ticker symbol"],
+        curr_date: Annotated[
+            str,
+            "current date you are trading at, yyyy-mm-dd",
+        ],
+    ):
+        """
+        Retrieve insider transaction information about a company (retrieved from public SEC information) for the past 30 days
+        Args:
+            ticker (str): ticker symbol of the company
+            curr_date (str): current date you are trading at, yyyy-mm-dd
+        Returns:
+            str: a report of the company's insider transactions/trading information in the past 30 days
+        """
+
+        data_trans = interface.get_finnhub_company_insider_transactions(
+            ticker, curr_date, 30
+        )
+
+        return data_trans
+
+    @staticmethod
+    @tool
+    def get_simfin_balance_sheet(
+        ticker: Annotated[str, "ticker symbol"],
+        freq: Annotated[
+            str,
+            "reporting frequency of the company's financial history: annual/quarterly",
+        ],
+        curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"],
+    ):
+        """
+        Retrieve the most recent balance sheet of a company
+        Args:
+            ticker (str): ticker symbol of the company
+            freq (str): reporting frequency of the company's financial history: annual / quarterly
+            curr_date (str): current date you are trading at, yyyy-mm-dd
+        Returns:
+            str: a report of the company's most recent balance sheet
+        """
+
+        data_balance_sheet = interface.get_simfin_balance_sheet(ticker, freq, curr_date)
+
+        return data_balance_sheet
+
+    @staticmethod
+    @tool
+    def get_simfin_cashflow(
+        ticker: Annotated[str, "ticker symbol"],
+        freq: Annotated[
+            str,
+            "reporting frequency of the company's financial history: annual/quarterly",
+        ],
+        curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"],
+    ):
+        """
+        Retrieve the most recent cash flow statement of a company
+        Args:
+            ticker (str): ticker symbol of the company
+            freq (str): reporting frequency of the company's financial history: annual / quarterly
+            curr_date (str): current date you are trading at, yyyy-mm-dd
+        Returns:
+                str: a report of the company's most recent cash flow statement
+        """
+
+        data_cashflow = interface.get_simfin_cashflow(ticker, freq, curr_date)
+
+        return data_cashflow
+
+    @staticmethod
+    @tool
+    def get_simfin_income_stmt(
+        ticker: Annotated[str, "ticker symbol"],
+        freq: Annotated[
+            str,
+            "reporting frequency of the company's financial history: annual/quarterly",
+        ],
+        curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"],
+    ):
+        """
+        Retrieve the most recent income statement of a company
+        Args:
+            ticker (str): ticker symbol of the company
+            freq (str): reporting frequency of the company's financial history: annual / quarterly
+            curr_date (str): current date you are trading at, yyyy-mm-dd
+        Returns:
+                str: a report of the company's most recent income statement
+        """
+
+        data_income_stmt = interface.get_simfin_income_statements(
+            ticker, freq, curr_date
+        )
+
+        return data_income_stmt
+
+    @staticmethod
+    @tool
+    def get_google_news(
+        query: Annotated[str, "Query to search with"],
+        curr_date: Annotated[str, "Curr date in yyyy-mm-dd format"],
+    ):
+        """
+        Retrieve the latest news from Google News based on a query and date range.
+        Args:
+            query (str): Query to search with
+            curr_date (str): Current date in yyyy-mm-dd format
+            look_back_days (int): How many days to look back
+        Returns:
+            str: A formatted string containing the latest news from Google News based on the query and date range.
+        """
+
+        google_news_results = interface.get_google_news(query, curr_date, 7)
+
+        return google_news_results
+
+    @staticmethod
+    @tool
+    def get_stock_news_openai(
+        ticker: Annotated[str, "the company's ticker"],
+        curr_date: Annotated[str, "Current date in yyyy-mm-dd format"],
+    ):
+        """
+        Retrieve the latest news about a given stock by using OpenAI's news API.
+        Args:
+            ticker (str): Ticker of a company. e.g. AAPL, TSM
+            curr_date (str): Current date in yyyy-mm-dd format
+        Returns:
+            str: A formatted string containing the latest news about the company on the given date.
+        """
+
+        openai_news_results = interface.get_stock_news_openai(ticker, curr_date)
+
+        return openai_news_results
+
+    @staticmethod
+    @tool
+    def get_global_news_openai(
+        curr_date: Annotated[str, "Current date in yyyy-mm-dd format"],
+    ):
+        """
+        Retrieve the latest macroeconomics news on a given date using OpenAI's macroeconomics news API.
+        Args:
+            curr_date (str): Current date in yyyy-mm-dd format
+        Returns:
+            str: A formatted string containing the latest macroeconomic news on the given date.
+        """
+
+        openai_news_results = interface.get_global_news_openai(curr_date)
+
+        return openai_news_results
+
+    @staticmethod
+    @tool
+    def get_fundamentals_openai(
+        ticker: Annotated[str, "the company's ticker"],
+        curr_date: Annotated[str, "Current date in yyyy-mm-dd format"],
+    ):
+        """
+        Retrieve the latest fundamental information about a given stock on a given date by using OpenAI's news API.
+        Args:
+            ticker (str): Ticker of a company. e.g. AAPL, TSM
+            curr_date (str): Current date in yyyy-mm-dd format
+        Returns:
+            str: A formatted string containing the latest fundamental information about the company on the given date.
+        """
+
+        openai_fundamentals_results = interface.get_fundamentals_openai(
+            ticker, curr_date
+        )
+
+        return openai_fundamentals_results

tradingagents/agents/utils/memory.py

@@ -0,0 +1,109 @@
+import chromadb
+from chromadb.config import Settings
+from openai import OpenAI
+import numpy as np
+
+
+class FinancialSituationMemory:
+    def __init__(self, name):
+        self.client = OpenAI()
+        self.chroma_client = chromadb.Client(Settings(allow_reset=True))
+        self.situation_collection = self.chroma_client.create_collection(name=name)
+
+    def get_embedding(self, text):
+        """Get OpenAI embedding for a text"""
+        response = self.client.embeddings.create(
+            model="text-embedding-ada-002", input=text
+        )
+        return response.data[0].embedding
+
+    def add_situations(self, situations_and_advice):
+        """Add financial situations and their corresponding advice. Parameter is a list of tuples (situation, rec)"""
+
+        situations = []
+        advice = []
+        ids = []
+        embeddings = []
+
+        offset = self.situation_collection.count()
+
+        for i, (situation, recommendation) in enumerate(situations_and_advice):
+            situations.append(situation)
+            advice.append(recommendation)
+            ids.append(str(offset + i))
+            embeddings.append(self.get_embedding(situation))
+
+        self.situation_collection.add(
+            documents=situations,
+            metadatas=[{"recommendation": rec} for rec in advice],
+            embeddings=embeddings,
+            ids=ids,
+        )
+
+    def get_memories(self, current_situation, n_matches=1):
+        """Find matching recommendations using OpenAI embeddings"""
+        query_embedding = self.get_embedding(current_situation)
+
+        results = self.situation_collection.query(
+            query_embeddings=[query_embedding],
+            n_results=n_matches,
+            include=["metadatas", "documents", "distances"],
+        )
+
+        matched_results = []
+        for i in range(len(results["documents"][0])):
+            matched_results.append(
+                {
+                    "matched_situation": results["documents"][0][i],
+                    "recommendation": results["metadatas"][0][i]["recommendation"],
+                    "similarity_score": 1 - results["distances"][0][i],
+                }
+            )
+
+        return matched_results
+
+
+if __name__ == "__main__":
+    # Example usage
+    matcher = FinancialSituationMemory()
+
+    # Example data
+    example_data = [
+        (
+            "High inflation rate with rising interest rates and declining consumer spending",
+            "Consider defensive sectors like consumer staples and utilities. Review fixed-income portfolio duration.",
+        ),
+        (
+            "Tech sector showing high volatility with increasing institutional selling pressure",
+            "Reduce exposure to high-growth tech stocks. Look for value opportunities in established tech companies with strong cash flows.",
+        ),
+        (
+            "Strong dollar affecting emerging markets with increasing forex volatility",
+            "Hedge currency exposure in international positions. Consider reducing allocation to emerging market debt.",
+        ),
+        (
+            "Market showing signs of sector rotation with rising yields",
+            "Rebalance portfolio to maintain target allocations. Consider increasing exposure to sectors benefiting from higher rates.",
+        ),
+    ]
+
+    # Add the example situations and recommendations
+    matcher.add_situations(example_data)
+
+    # Example query
+    current_situation = """
+    Market showing increased volatility in tech sector, with institutional investors 
+    reducing positions and rising interest rates affecting growth stock valuations
+    """
+
+    try:
+        recommendations = matcher.get_memories(current_situation, n_matches=2)
+
+        for i, rec in enumerate(recommendations, 1):
+            print(f"\nMatch {i}:")
+            print(f"Similarity Score: {rec['similarity_score']:.2f}")
+            print(f"Matched Situation: {rec['matched_situation']}")
+            print(f"Recommendation: {rec['recommendation']}")
+
+    except Exception as e:
+        print(f"Error during recommendation: {str(e)}")