diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8313619 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +env/ +__pycache__/ +.DS_Store +*.csv +src/ +eval_results/ +eval_data/ +*.egg-info/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index 015891a..d2fd70f 100644 --- a/README.md +++ b/README.md @@ -1,23 +1,190 @@ -# TradingAgents: Multi-Agents LLM Financial Trading Framework +

+ +

-> MARW Workshop, AAAI 2025 -> -> Homepage: https://TradingAgents-AI.github.io/ +
+ arXiv + Discord + WeChat + X Follow +
+ Community +
+--- -**Update** -We will release the framework by providing source code or in the form of API recently. Please keep tuned and thanks for your patience! +# TradingAgents: Multi-Agents LLM Financial Trading Framework +> 🎉 **TradingAgents** officially released! We have received numerous inquiries about the work, and we would like to express our thanks for the enthusiasm in our community. +> +> So we decided to fully open-source the framework. Looking forward to building impactful projects with you! + +
+ +🚀 [TradingAgents](#tradingagents-framework) | ⚡ [Installation & CLI](#installation-and-cli) | 🎬 [Demo](https://www.youtube.com/watch?v=90gr5lwjIho) | 📦 [Package Usage](#tradingagents-package) | 🤝 [Contributing](#contributing) | 📄 [Citation](#citation) + +
+ +## TradingAgents Framework + +TradingAgents is a multi-agent trading framework that mirrors the dynamics of real-world trading firms. By deploying specialized LLM-powered agents: from fundamental analysts, sentiment experts, and technical analysts, to trader, risk management team, the platform collaboratively evaluates market conditions and informs trading decisions. Moreover, these agents engage in dynamic discussions to pinpoint the optimal strategy. + +

+ +

+ +> TradingAgents framework is designed for research purposes. Trading performance may vary based on many factors, including the chosen backbone language models, model temperature, trading periods, the quality of data, and other non-deterministic factors. [It is not intended as financial, investment, or trading advice.](https://tauric.ai/disclaimer/) + +Our framework decomposes complex trading tasks into specialized roles. This ensures the system achieves a robust, scalable approach to market analysis and decision-making. + +### Analyst Team +- Fundamentals Analyst: Evaluates company financials and performance metrics, identifying intrinsic values and potential red flags. +- Sentiment Analyst: Analyzes social media and public sentiment using sentiment scoring algorithms to gauge short-term market mood. +- News Analyst: Monitors global news and macroeconomic indicators, interpreting the impact of events on market conditions. +- Technical Analyst: Utilizes technical indicators (like MACD and RSI) to detect trading patterns and forecast price movements. + +

+ +

+ +### Researcher Team +- Comprises both bullish and bearish researchers who critically assess the insights provided by the Analyst Team. Through structured debates, they balance potential gains against inherent risks. + +

+ +

+ +### Trader Agent +- Composes reports from the analysts and researchers to make informed trading decisions. It determines the timing and magnitude of trades based on comprehensive market insights. + +

+ +

+ +### Risk Management and Portfolio Manager +- Continuously evaluates portfolio risk by assessing market volatility, liquidity, and other risk factors. The risk management team evaluates and adjusts trading strategies, providing assessment reports to the Portfolio Manager for final decision. +- The Portfolio Manager approves/rejects the transaction proposal. If approved, the order will be sent to the simulated exchange and executed. + +

+ +

+ +## Installation and CLI + +### Installation + +Clone TradingAgents: +```bash +git clone https://github.com/TauricResearch/TradingAgents.git +cd TradingAgents +``` + +Create a virtual environment in any of your favorite environment managers: +```bash +conda create -n tradingagents python=3.13 +conda activate tradingagents +``` + +Install dependencies: +```bash +pip install -r requirements.txt +``` + +### Required APIs + +You will also need the FinnHub API and EODHD API for financial data. All of our code is implemented with the free tier. +```bash +export FINNHUB_API_KEY=$YOUR_FINNHUB_API_KEY +``` + +You will need the OpenAI API for all the agents. +```bash +export OPENAI_API_KEY=$YOUR_OPENAI_API_KEY +``` + +### CLI Usage + +You can also try out the CLI directly by running: +```bash +python -m cli.main +``` +You will see a screen where you can select your desired tickers, date, LLMs, research depth, etc. + +

+ +

+ +An interface will appear showing results as they load, letting you track the agent's progress as it runs. + +

+ +

+ +

+ +

+ +## TradingAgents Package + +### Implementation Details + +We built TradingAgents with LangGraph to ensure flexibility and modularity. We utilize `o1-preview` and `gpt-4o` as our deep thinking and fast thinking LLMs for our experiments. However, for testing purposes, we recommend you use `o4-mini` and `gpt-4.1-mini` to save on costs as our framework makes **lots of** API calls. + +### Python Usage + +To use TradingAgents inside your code, you can import the `tradingagents` module and initialize a `TradingAgentsGraph()` object. The `.propagate()` function will return a decision. You can run `main.py`, here's also a quick example: + +```python +from tradingagents.graph.trading_graph import TradingAgentsGraph + +ta = TradingAgentsGraph(debug=True, config=config) + +# forward propagate +_, decision = ta.propagate("NVDA", "2024-05-10") +print(decision) +``` + +You can also adjust the default configuration to set your own choice of LLMs, debate rounds, etc. + +```python +from tradingagents.graph.trading_graph import TradingAgentsGraph +from tradingagents.default_config import DEFAULT_CONFIG + +# Create a custom config +config = DEFAULT_CONFIG.copy() +config["deep_think_llm"] = "gpt-4.1-nano" # Use a different model +config["quick_think_llm"] = "gpt-4.1-nano" # Use a different model +config["max_debate_rounds"] = 1 # Increase debate rounds +config["online_tools"] = True # Use online tools or cached data + +# Initialize with custom config +ta = TradingAgentsGraph(debug=True, config=config) + +# forward propagate +_, decision = ta.propagate("NVDA", "2024-05-10") +print(decision) +``` + +> For `online_tools`, we recommend enabling them for experimentation, as they provide access to real-time data. The agents' offline tools rely on cached data from our **Tauric TradingDB**, a curated dataset we use for backtesting. We're currently in the process of refining this dataset, and we plan to release it soon alongside our upcoming projects. Stay tuned! + +You can view the full list of configurations in `tradingagents/default_config.py`. + +## Contributing + +We welcome contributions from the community! Whether it's fixing a bug, improving documentation, or suggesting a new feature, your input helps make this project better. If you are interested in this line of research, please consider joining our open-source financial AI research community [Tauric Research](https://tauric.ai/). ## Citation Please reference our work if you find *TradingAgents* provides you with some help :) ``` -@article{xiao2024tradingagents, - title={TradingAgents: Multi-Agents LLM Financial Trading Framework}, - author={Xiao, Yijia and Sun, Edward and Luo, Di and Wang, Wei}, - journal={arXiv preprint arXiv:2412.20138}, - year={2024} +@misc{xiao2025tradingagentsmultiagentsllmfinancial, + title={TradingAgents: Multi-Agents LLM Financial Trading Framework}, + author={Yijia Xiao and Edward Sun and Di Luo and Wei Wang}, + year={2025}, + eprint={2412.20138}, + archivePrefix={arXiv}, + primaryClass={q-fin.TR}, + url={https://arxiv.org/abs/2412.20138}, } ``` diff --git a/assets/TauricResearch.png b/assets/TauricResearch.png new file mode 100644 index 0000000..3e88994 Binary files /dev/null and b/assets/TauricResearch.png differ diff --git a/assets/analyst.png b/assets/analyst.png new file mode 100644 index 0000000..9c89a6e Binary files /dev/null and b/assets/analyst.png differ diff --git a/assets/cli/cli_init.png b/assets/cli/cli_init.png new file mode 100644 index 0000000..eeb2b63 Binary files /dev/null and b/assets/cli/cli_init.png differ diff --git a/assets/cli/cli_news.png b/assets/cli/cli_news.png new file mode 100644 index 0000000..b5d33be Binary files /dev/null and b/assets/cli/cli_news.png differ diff --git a/assets/cli/cli_technical.png b/assets/cli/cli_technical.png new file mode 100644 index 0000000..5fd363a Binary files /dev/null and b/assets/cli/cli_technical.png differ diff --git a/assets/cli/cli_transaction.png b/assets/cli/cli_transaction.png new file mode 100644 index 0000000..ab36d2b Binary files /dev/null and b/assets/cli/cli_transaction.png differ diff --git a/assets/researcher.png b/assets/researcher.png new file mode 100644 index 0000000..8301534 Binary files /dev/null and b/assets/researcher.png differ diff --git a/assets/risk.png b/assets/risk.png new file mode 100644 index 0000000..5708dc4 Binary files /dev/null and b/assets/risk.png differ diff --git a/assets/schema.png b/assets/schema.png new file mode 100644 index 0000000..549f8c5 Binary files /dev/null and b/assets/schema.png differ diff --git a/assets/trader.png b/assets/trader.png new file mode 100644 index 0000000..2bd7f51 Binary files /dev/null and b/assets/trader.png differ diff --git a/assets/wechat.png b/assets/wechat.png new file mode 100644 index 0000000..9435568 Binary files /dev/null and b/assets/wechat.png differ diff --git a/cli/__init__.py b/cli/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cli/main.py b/cli/main.py new file mode 100644 index 0000000..e7bed4e --- /dev/null +++ b/cli/main.py @@ -0,0 +1,1009 @@ +from typing import Optional +import datetime +import typer +from rich.console import Console +from rich.panel import Panel +from rich.spinner import Spinner +from rich.live import Live +from rich.columns import Columns +from rich.markdown import Markdown +from rich.layout import Layout +from rich.text import Text +from rich.live import Live +from rich.table import Table +from collections import deque +import time +from rich.tree import Tree +from rich import box +from rich.align import Align +from rich.rule import Rule + +from tradingagents.graph.trading_graph import TradingAgentsGraph +from tradingagents.default_config import DEFAULT_CONFIG +from cli.models import AnalystType +from cli.utils import * + +console = Console() + +app = typer.Typer( + name="TradingAgents", + help="TradingAgents CLI: Multi-Agents LLM Financial Trading Framework", + add_completion=True, # Enable shell completion +) + + +# Create a deque to store recent messages with a maximum length +class MessageBuffer: + def __init__(self, max_length=100): + self.messages = deque(maxlen=max_length) + self.tool_calls = deque(maxlen=max_length) + self.current_report = None + self.final_report = None # Store the complete final report + self.agent_status = { + # Analyst Team + "Market Analyst": "pending", + "Social Analyst": "pending", + "News Analyst": "pending", + "Fundamentals Analyst": "pending", + # Research Team + "Bull Researcher": "pending", + "Bear Researcher": "pending", + "Research Manager": "pending", + # Trading Team + "Trader": "pending", + # Risk Management Team + "Risky Analyst": "pending", + "Neutral Analyst": "pending", + "Safe Analyst": "pending", + # Portfolio Management Team + "Portfolio Manager": "pending", + } + self.current_agent = None + self.report_sections = { + "market_report": None, + "sentiment_report": None, + "news_report": None, + "fundamentals_report": None, + "investment_plan": None, + "trader_investment_plan": None, + "final_trade_decision": None, + } + + def add_message(self, message_type, content): + timestamp = datetime.datetime.now().strftime("%H:%M:%S") + self.messages.append((timestamp, message_type, content)) + + def add_tool_call(self, tool_name, args): + timestamp = datetime.datetime.now().strftime("%H:%M:%S") + self.tool_calls.append((timestamp, tool_name, args)) + + def update_agent_status(self, agent, status): + if agent in self.agent_status: + self.agent_status[agent] = status + self.current_agent = agent + + def update_report_section(self, section_name, content): + if section_name in self.report_sections: + self.report_sections[section_name] = content + self._update_current_report() + + def _update_current_report(self): + # For the panel display, only show the most recently updated section + latest_section = None + latest_content = None + + # Find the most recently updated section + for section, content in self.report_sections.items(): + if content is not None: + latest_section = section + latest_content = content + + if latest_section and latest_content: + # Format the current section for display + section_titles = { + "market_report": "Market Analysis", + "sentiment_report": "Social Sentiment", + "news_report": "News Analysis", + "fundamentals_report": "Fundamentals Analysis", + "investment_plan": "Research Team Decision", + "trader_investment_plan": "Trading Team Plan", + "final_trade_decision": "Portfolio Management Decision", + } + self.current_report = ( + f"### {section_titles[latest_section]}\n{latest_content}" + ) + + # Update the final complete report + self._update_final_report() + + def _update_final_report(self): + report_parts = [] + + # Analyst Team Reports + if any( + self.report_sections[section] + for section in [ + "market_report", + "sentiment_report", + "news_report", + "fundamentals_report", + ] + ): + report_parts.append("## Analyst Team Reports") + if self.report_sections["market_report"]: + report_parts.append( + f"### Market Analysis\n{self.report_sections['market_report']}" + ) + if self.report_sections["sentiment_report"]: + report_parts.append( + f"### Social Sentiment\n{self.report_sections['sentiment_report']}" + ) + if self.report_sections["news_report"]: + report_parts.append( + f"### News Analysis\n{self.report_sections['news_report']}" + ) + if self.report_sections["fundamentals_report"]: + report_parts.append( + f"### Fundamentals Analysis\n{self.report_sections['fundamentals_report']}" + ) + + # Research Team Reports + if self.report_sections["investment_plan"]: + report_parts.append("## Research Team Decision") + report_parts.append(f"{self.report_sections['investment_plan']}") + + # Trading Team Reports + if self.report_sections["trader_investment_plan"]: + report_parts.append("## Trading Team Plan") + report_parts.append(f"{self.report_sections['trader_investment_plan']}") + + # Portfolio Management Decision + if self.report_sections["final_trade_decision"]: + report_parts.append("## Portfolio Management Decision") + report_parts.append(f"{self.report_sections['final_trade_decision']}") + + self.final_report = "\n\n".join(report_parts) if report_parts else None + + +message_buffer = MessageBuffer() + + +def create_layout(): + layout = Layout() + layout.split_column( + Layout(name="header", size=3), + Layout(name="main"), + Layout(name="footer", size=3), + ) + layout["main"].split_column( + Layout(name="upper", ratio=3), Layout(name="analysis", ratio=5) + ) + layout["upper"].split_row( + Layout(name="progress", ratio=2), Layout(name="messages", ratio=3) + ) + return layout + + +def update_display(layout, spinner_text=None): + # Header with welcome message + layout["header"].update( + Panel( + "[bold green]Welcome to TradingAgents CLI[/bold green]\n" + "[dim]© [Tauric Research](https://github.com/TauricResearch)[/dim]", + title="Welcome to TradingAgents", + border_style="green", + padding=(1, 2), + expand=True, + ) + ) + + # Progress panel showing agent status + progress_table = Table( + show_header=True, + header_style="bold magenta", + show_footer=False, + box=box.SIMPLE_HEAD, # Use simple header with horizontal lines + title=None, # Remove the redundant Progress title + padding=(0, 2), # Add horizontal padding + expand=True, # Make table expand to fill available space + ) + progress_table.add_column("Team", style="cyan", justify="center", width=20) + progress_table.add_column("Agent", style="green", justify="center", width=20) + progress_table.add_column("Status", style="yellow", justify="center", width=20) + + # Group agents by team + teams = { + "Analyst Team": [ + "Market Analyst", + "Social Analyst", + "News Analyst", + "Fundamentals Analyst", + ], + "Research Team": ["Bull Researcher", "Bear Researcher", "Research Manager"], + "Trading Team": ["Trader"], + "Risk Management": ["Risky Analyst", "Neutral Analyst", "Safe Analyst"], + "Portfolio Management": ["Portfolio Manager"], + } + + for team, agents in teams.items(): + # Add first agent with team name + first_agent = agents[0] + status = message_buffer.agent_status[first_agent] + if status == "in_progress": + spinner = Spinner( + "dots", text="[blue]in_progress[/blue]", style="bold cyan" + ) + status_cell = spinner + else: + status_color = { + "pending": "yellow", + "completed": "green", + "error": "red", + }.get(status, "white") + status_cell = f"[{status_color}]{status}[/{status_color}]" + progress_table.add_row(team, first_agent, status_cell) + + # Add remaining agents in team + for agent in agents[1:]: + status = message_buffer.agent_status[agent] + if status == "in_progress": + spinner = Spinner( + "dots", text="[blue]in_progress[/blue]", style="bold cyan" + ) + status_cell = spinner + else: + status_color = { + "pending": "yellow", + "completed": "green", + "error": "red", + }.get(status, "white") + status_cell = f"[{status_color}]{status}[/{status_color}]" + progress_table.add_row("", agent, status_cell) + + # Add horizontal line after each team + progress_table.add_row("─" * 20, "─" * 20, "─" * 20, style="dim") + + layout["progress"].update( + Panel(progress_table, title="Progress", border_style="cyan", padding=(1, 2)) + ) + + # Messages panel showing recent messages and tool calls + messages_table = Table( + show_header=True, + header_style="bold magenta", + show_footer=False, + expand=True, # Make table expand to fill available space + box=box.MINIMAL, # Use minimal box style for a lighter look + show_lines=True, # Keep horizontal lines + padding=(0, 1), # Add some padding between columns + ) + messages_table.add_column("Time", style="cyan", width=8, justify="center") + messages_table.add_column("Type", style="green", width=10, justify="center") + messages_table.add_column( + "Content", style="white", no_wrap=False, ratio=1 + ) # Make content column expand + + # Combine tool calls and messages + all_messages = [] + + # Add tool calls + for timestamp, tool_name, args in message_buffer.tool_calls: + # Truncate tool call args if too long + if isinstance(args, str) and len(args) > 100: + args = args[:97] + "..." + all_messages.append((timestamp, "Tool", f"{tool_name}: {args}")) + + # Add regular messages + for timestamp, msg_type, content in message_buffer.messages: + # Truncate message content if too long + if isinstance(content, str) and len(content) > 200: + content = content[:197] + "..." + all_messages.append((timestamp, msg_type, content)) + + # Sort by timestamp + all_messages.sort(key=lambda x: x[0]) + + # Calculate how many messages we can show based on available space + # Start with a reasonable number and adjust based on content length + max_messages = 12 # Increased from 8 to better fill the space + + # Get the last N messages that will fit in the panel + recent_messages = all_messages[-max_messages:] + + # Add messages to table + for timestamp, msg_type, content in recent_messages: + # Format content with word wrapping + wrapped_content = Text(content, overflow="fold") + messages_table.add_row(timestamp, msg_type, wrapped_content) + + if spinner_text: + messages_table.add_row("", "Spinner", spinner_text) + + # Add a footer to indicate if messages were truncated + if len(all_messages) > max_messages: + messages_table.footer = ( + f"[dim]Showing last {max_messages} of {len(all_messages)} messages[/dim]" + ) + + layout["messages"].update( + Panel( + messages_table, + title="Messages & Tools", + border_style="blue", + padding=(1, 2), + ) + ) + + # Analysis panel showing current report + if message_buffer.current_report: + layout["analysis"].update( + Panel( + Markdown(message_buffer.current_report), + title="Current Report", + border_style="green", + padding=(1, 2), + ) + ) + else: + layout["analysis"].update( + Panel( + "[italic]Waiting for analysis report...[/italic]", + title="Current Report", + border_style="green", + padding=(1, 2), + ) + ) + + # Footer with statistics + tool_calls_count = len(message_buffer.tool_calls) + llm_calls_count = sum( + 1 for _, msg_type, _ in message_buffer.messages if msg_type == "Reasoning" + ) + reports_count = sum( + 1 for content in message_buffer.report_sections.values() if content is not None + ) + + stats_table = Table(show_header=False, box=None, padding=(0, 2), expand=True) + stats_table.add_column("Stats", justify="center") + stats_table.add_row( + f"Tool Calls: {tool_calls_count} | LLM Calls: {llm_calls_count} | Generated Reports: {reports_count}" + ) + + layout["footer"].update(Panel(stats_table, border_style="grey50")) + + +def get_user_selections(): + """Get all user selections before starting the analysis display.""" + # Display ASCII art welcome message + with open("./cli/static/welcome.txt", "r") as f: + welcome_ascii = f.read() + + # Create welcome box content + welcome_content = f"{welcome_ascii}\n" + welcome_content += "[bold green]TradingAgents: Multi-Agents LLM Financial Trading Framework - CLI[/bold green]\n\n" + welcome_content += "[bold]Workflow Steps:[/bold]\n" + welcome_content += "I. Analyst Team → II. Research Team → III. Trader → IV. Risk Management → V. Portfolio Management\n\n" + welcome_content += ( + "[dim]Built by [Tauric Research](https://github.com/TauricResearch)[/dim]" + ) + + # Create and center the welcome box + welcome_box = Panel( + welcome_content, + border_style="green", + padding=(1, 2), + title="Welcome to TradingAgents", + subtitle="Multi-Agents LLM Financial Trading Framework", + ) + console.print(Align.center(welcome_box)) + console.print() # Add a blank line after the welcome box + + # Create a boxed questionnaire for each step + def create_question_box(title, prompt, default=None): + box_content = f"[bold]{title}[/bold]\n" + box_content += f"[dim]{prompt}[/dim]" + if default: + box_content += f"\n[dim]Default: {default}[/dim]" + return Panel(box_content, border_style="blue", padding=(1, 2)) + + # Step 1: Ticker symbol + console.print( + create_question_box( + "Step 1: Ticker Symbol", "Enter the ticker symbol to analyze", "SPY" + ) + ) + selected_ticker = get_ticker() + + # Step 2: Analysis date + default_date = datetime.datetime.now().strftime("%Y-%m-%d") + console.print( + create_question_box( + "Step 2: Analysis Date", + "Enter the analysis date (YYYY-MM-DD)", + default_date, + ) + ) + analysis_date = get_analysis_date() + + # Step 3: Select analysts + console.print( + create_question_box( + "Step 3: Analysts Team", "Select your LLM analyst agents for the analysis" + ) + ) + selected_analysts = select_analysts() + console.print( + f"[green]Selected analysts:[/green] {', '.join(analyst.value for analyst in selected_analysts)}" + ) + + # Step 4: Research depth + console.print( + create_question_box( + "Step 4: Research Depth", "Select your research depth level" + ) + ) + selected_research_depth = select_research_depth() + + # Step 5: Thinking agents + console.print( + create_question_box( + "Step 5: Thinking Agents", "Select your thinking agents for analysis" + ) + ) + selected_shallow_thinker = select_shallow_thinking_agent() + selected_deep_thinker = select_deep_thinking_agent() + + return { + "ticker": selected_ticker, + "analysis_date": analysis_date, + "analysts": selected_analysts, + "research_depth": selected_research_depth, + "shallow_thinker": selected_shallow_thinker, + "deep_thinker": selected_deep_thinker, + } + + +def get_ticker(): + """Get ticker symbol from user input.""" + return typer.prompt("", default="SPY") + + +def get_analysis_date(): + """Get the analysis date from user input.""" + while True: + date_str = typer.prompt( + "", default=datetime.datetime.now().strftime("%Y-%m-%d") + ) + try: + # Validate date format and ensure it's not in the future + analysis_date = datetime.datetime.strptime(date_str, "%Y-%m-%d") + if analysis_date.date() > datetime.datetime.now().date(): + console.print("[red]Error: Analysis date cannot be in the future[/red]") + continue + return date_str + except ValueError: + console.print( + "[red]Error: Invalid date format. Please use YYYY-MM-DD[/red]" + ) + + +def display_complete_report(final_state): + """Display the complete analysis report with team-based panels.""" + console.print("\n[bold green]Complete Analysis Report[/bold green]\n") + + # I. Analyst Team Reports + analyst_reports = [] + + # Market Analyst Report + if final_state.get("market_report"): + analyst_reports.append( + Panel( + Markdown(final_state["market_report"]), + title="Market Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + # Social Analyst Report + if final_state.get("sentiment_report"): + analyst_reports.append( + Panel( + Markdown(final_state["sentiment_report"]), + title="Social Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + # News Analyst Report + if final_state.get("news_report"): + analyst_reports.append( + Panel( + Markdown(final_state["news_report"]), + title="News Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + # Fundamentals Analyst Report + if final_state.get("fundamentals_report"): + analyst_reports.append( + Panel( + Markdown(final_state["fundamentals_report"]), + title="Fundamentals Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + if analyst_reports: + console.print( + Panel( + Columns(analyst_reports, equal=True, expand=True), + title="I. Analyst Team Reports", + border_style="cyan", + padding=(1, 2), + ) + ) + + # II. Research Team Reports + if final_state.get("investment_debate_state"): + research_reports = [] + debate_state = final_state["investment_debate_state"] + + # Bull Researcher Analysis + if debate_state.get("bull_history"): + research_reports.append( + Panel( + Markdown(debate_state["bull_history"]), + title="Bull Researcher", + border_style="blue", + padding=(1, 2), + ) + ) + + # Bear Researcher Analysis + if debate_state.get("bear_history"): + research_reports.append( + Panel( + Markdown(debate_state["bear_history"]), + title="Bear Researcher", + border_style="blue", + padding=(1, 2), + ) + ) + + # Research Manager Decision + if debate_state.get("judge_decision"): + research_reports.append( + Panel( + Markdown(debate_state["judge_decision"]), + title="Research Manager", + border_style="blue", + padding=(1, 2), + ) + ) + + if research_reports: + console.print( + Panel( + Columns(research_reports, equal=True, expand=True), + title="II. Research Team Decision", + border_style="magenta", + padding=(1, 2), + ) + ) + + # III. Trading Team Reports + if final_state.get("trader_investment_plan"): + console.print( + Panel( + Panel( + Markdown(final_state["trader_investment_plan"]), + title="Trader", + border_style="blue", + padding=(1, 2), + ), + title="III. Trading Team Plan", + border_style="yellow", + padding=(1, 2), + ) + ) + + # IV. Risk Management Team Reports + if final_state.get("risk_debate_state"): + risk_reports = [] + risk_state = final_state["risk_debate_state"] + + # Aggressive (Risky) Analyst Analysis + if risk_state.get("risky_history"): + risk_reports.append( + Panel( + Markdown(risk_state["risky_history"]), + title="Aggressive Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + # Conservative (Safe) Analyst Analysis + if risk_state.get("safe_history"): + risk_reports.append( + Panel( + Markdown(risk_state["safe_history"]), + title="Conservative Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + # Neutral Analyst Analysis + if risk_state.get("neutral_history"): + risk_reports.append( + Panel( + Markdown(risk_state["neutral_history"]), + title="Neutral Analyst", + border_style="blue", + padding=(1, 2), + ) + ) + + if risk_reports: + console.print( + Panel( + Columns(risk_reports, equal=True, expand=True), + title="IV. Risk Management Team Decision", + border_style="red", + padding=(1, 2), + ) + ) + + # V. Portfolio Manager Decision + if risk_state.get("judge_decision"): + console.print( + Panel( + Panel( + Markdown(risk_state["judge_decision"]), + title="Portfolio Manager", + border_style="blue", + padding=(1, 2), + ), + title="V. Portfolio Manager Decision", + border_style="green", + padding=(1, 2), + ) + ) + + +def update_research_team_status(status): + """Update status for all research team members and trader.""" + research_team = ["Bull Researcher", "Bear Researcher", "Research Manager", "Trader"] + for agent in research_team: + message_buffer.update_agent_status(agent, status) + + +def run_analysis(): + # First get all user selections + selections = get_user_selections() + + # Create config with selected research depth + config = DEFAULT_CONFIG.copy() + config["max_debate_rounds"] = selections["research_depth"] + config["max_risk_discuss_rounds"] = selections["research_depth"] + config["quick_think_llm"] = selections["shallow_thinker"] + config["deep_think_llm"] = selections["deep_thinker"] + + # Initialize the graph + graph = TradingAgentsGraph( + [analyst.value for analyst in selections["analysts"]], config=config, debug=True + ) + + # Now start the display layout + layout = create_layout() + + with Live(layout, refresh_per_second=4) as live: + # Initial display + update_display(layout) + + # Add initial messages + message_buffer.add_message("System", f"Selected ticker: {selections['ticker']}") + message_buffer.add_message( + "System", f"Analysis date: {selections['analysis_date']}" + ) + message_buffer.add_message( + "System", + f"Selected analysts: {', '.join(analyst.value for analyst in selections['analysts'])}", + ) + update_display(layout) + + # Reset agent statuses + for agent in message_buffer.agent_status: + message_buffer.update_agent_status(agent, "pending") + + # Reset report sections + for section in message_buffer.report_sections: + message_buffer.report_sections[section] = None + message_buffer.current_report = None + message_buffer.final_report = None + + # Update agent status to in_progress for the first analyst + first_analyst = f"{selections['analysts'][0].value.capitalize()} Analyst" + message_buffer.update_agent_status(first_analyst, "in_progress") + update_display(layout) + + # Create spinner text + spinner_text = ( + f"Analyzing {selections['ticker']} on {selections['analysis_date']}..." + ) + update_display(layout, spinner_text) + + # Initialize state and get graph args + init_agent_state = graph.propagator.create_initial_state( + selections["ticker"], selections["analysis_date"] + ) + args = graph.propagator.get_graph_args() + + # Stream the analysis + trace = [] + for chunk in graph.graph.stream(init_agent_state, **args): + if len(chunk["messages"]) > 0: + # Get the last message from the chunk + last_message = chunk["messages"][-1] + + # Extract message content and type + if hasattr(last_message, "content"): + content = last_message.content + msg_type = "Reasoning" + else: + content = str(last_message) + msg_type = "System" + + # Add message to buffer + message_buffer.add_message(msg_type, content) + + # If it's a tool call, add it to tool calls + if hasattr(last_message, "tool_calls"): + for tool_call in last_message.tool_calls: + # Handle both dictionary and object tool calls + if isinstance(tool_call, dict): + message_buffer.add_tool_call( + tool_call["name"], tool_call["args"] + ) + else: + message_buffer.add_tool_call(tool_call.name, tool_call.args) + + # Update reports and agent status based on chunk content + # Analyst Team Reports + if "market_report" in chunk and chunk["market_report"]: + message_buffer.update_report_section( + "market_report", chunk["market_report"] + ) + message_buffer.update_agent_status("Market Analyst", "completed") + # Set next analyst to in_progress + if "social" in selections["analysts"]: + message_buffer.update_agent_status( + "Social Analyst", "in_progress" + ) + + if "sentiment_report" in chunk and chunk["sentiment_report"]: + message_buffer.update_report_section( + "sentiment_report", chunk["sentiment_report"] + ) + message_buffer.update_agent_status("Social Analyst", "completed") + # Set next analyst to in_progress + if "news" in selections["analysts"]: + message_buffer.update_agent_status( + "News Analyst", "in_progress" + ) + + if "news_report" in chunk and chunk["news_report"]: + message_buffer.update_report_section( + "news_report", chunk["news_report"] + ) + message_buffer.update_agent_status("News Analyst", "completed") + # Set next analyst to in_progress + if "fundamentals" in selections["analysts"]: + message_buffer.update_agent_status( + "Fundamentals Analyst", "in_progress" + ) + + if "fundamentals_report" in chunk and chunk["fundamentals_report"]: + message_buffer.update_report_section( + "fundamentals_report", chunk["fundamentals_report"] + ) + message_buffer.update_agent_status( + "Fundamentals Analyst", "completed" + ) + # Set all research team members to in_progress + update_research_team_status("in_progress") + + # Research Team - Handle Investment Debate State + if ( + "investment_debate_state" in chunk + and chunk["investment_debate_state"] + ): + debate_state = chunk["investment_debate_state"] + + # Update Bull Researcher status and report + if "bull_history" in debate_state and debate_state["bull_history"]: + # Keep all research team members in progress + update_research_team_status("in_progress") + # Extract latest bull response + bull_responses = debate_state["bull_history"].split("\n") + latest_bull = bull_responses[-1] if bull_responses else "" + if latest_bull: + message_buffer.add_message("Reasoning", latest_bull) + # Update research report with bull's latest analysis + message_buffer.update_report_section( + "investment_plan", + f"### Bull Researcher Analysis\n{latest_bull}", + ) + + # Update Bear Researcher status and report + if "bear_history" in debate_state and debate_state["bear_history"]: + # Keep all research team members in progress + update_research_team_status("in_progress") + # Extract latest bear response + bear_responses = debate_state["bear_history"].split("\n") + latest_bear = bear_responses[-1] if bear_responses else "" + if latest_bear: + message_buffer.add_message("Reasoning", latest_bear) + # Update research report with bear's latest analysis + message_buffer.update_report_section( + "investment_plan", + f"{message_buffer.report_sections['investment_plan']}\n\n### Bear Researcher Analysis\n{latest_bear}", + ) + + # Update Research Manager status and final decision + if ( + "judge_decision" in debate_state + and debate_state["judge_decision"] + ): + # Keep all research team members in progress until final decision + update_research_team_status("in_progress") + message_buffer.add_message( + "Reasoning", + f"Research Manager: {debate_state['judge_decision']}", + ) + # Update research report with final decision + message_buffer.update_report_section( + "investment_plan", + f"{message_buffer.report_sections['investment_plan']}\n\n### Research Manager Decision\n{debate_state['judge_decision']}", + ) + # Mark all research team members as completed + update_research_team_status("completed") + # Set first risk analyst to in_progress + message_buffer.update_agent_status( + "Risky Analyst", "in_progress" + ) + + # Trading Team + if ( + "trader_investment_plan" in chunk + and chunk["trader_investment_plan"] + ): + message_buffer.update_report_section( + "trader_investment_plan", chunk["trader_investment_plan"] + ) + # Set first risk analyst to in_progress + message_buffer.update_agent_status("Risky Analyst", "in_progress") + + # Risk Management Team - Handle Risk Debate State + if "risk_debate_state" in chunk and chunk["risk_debate_state"]: + risk_state = chunk["risk_debate_state"] + + # Update Risky Analyst status and report + if ( + "current_risky_response" in risk_state + and risk_state["current_risky_response"] + ): + message_buffer.update_agent_status( + "Risky Analyst", "in_progress" + ) + message_buffer.add_message( + "Reasoning", + f"Risky Analyst: {risk_state['current_risky_response']}", + ) + # Update risk report with risky analyst's latest analysis only + message_buffer.update_report_section( + "final_trade_decision", + f"### Risky Analyst Analysis\n{risk_state['current_risky_response']}", + ) + + # Update Safe Analyst status and report + if ( + "current_safe_response" in risk_state + and risk_state["current_safe_response"] + ): + message_buffer.update_agent_status( + "Safe Analyst", "in_progress" + ) + message_buffer.add_message( + "Reasoning", + f"Safe Analyst: {risk_state['current_safe_response']}", + ) + # Update risk report with safe analyst's latest analysis only + message_buffer.update_report_section( + "final_trade_decision", + f"### Safe Analyst Analysis\n{risk_state['current_safe_response']}", + ) + + # Update Neutral Analyst status and report + if ( + "current_neutral_response" in risk_state + and risk_state["current_neutral_response"] + ): + message_buffer.update_agent_status( + "Neutral Analyst", "in_progress" + ) + message_buffer.add_message( + "Reasoning", + f"Neutral Analyst: {risk_state['current_neutral_response']}", + ) + # Update risk report with neutral analyst's latest analysis only + message_buffer.update_report_section( + "final_trade_decision", + f"### Neutral Analyst Analysis\n{risk_state['current_neutral_response']}", + ) + + # Update Portfolio Manager status and final decision + if "judge_decision" in risk_state and risk_state["judge_decision"]: + message_buffer.update_agent_status( + "Portfolio Manager", "in_progress" + ) + message_buffer.add_message( + "Reasoning", + f"Portfolio Manager: {risk_state['judge_decision']}", + ) + # Update risk report with final decision only + message_buffer.update_report_section( + "final_trade_decision", + f"### Portfolio Manager Decision\n{risk_state['judge_decision']}", + ) + # Mark risk analysts as completed + message_buffer.update_agent_status("Risky Analyst", "completed") + message_buffer.update_agent_status("Safe Analyst", "completed") + message_buffer.update_agent_status( + "Neutral Analyst", "completed" + ) + message_buffer.update_agent_status( + "Portfolio Manager", "completed" + ) + + # Update the display + update_display(layout) + + trace.append(chunk) + + # Get final state and decision + final_state = trace[-1] + decision = graph.process_signal(final_state["final_trade_decision"]) + + # Update all agent statuses to completed + for agent in message_buffer.agent_status: + message_buffer.update_agent_status(agent, "completed") + + message_buffer.add_message( + "Analysis", f"Completed analysis for {selections['analysis_date']}" + ) + + # Update final report sections + for section in message_buffer.report_sections.keys(): + if section in final_state: + message_buffer.update_report_section(section, final_state[section]) + + # Display the complete final report + display_complete_report(final_state) + + update_display(layout) + + +@app.command() +def analyze(): + run_analysis() + + +if __name__ == "__main__": + app() diff --git a/cli/models.py b/cli/models.py new file mode 100644 index 0000000..f68c3da --- /dev/null +++ b/cli/models.py @@ -0,0 +1,10 @@ +from enum import Enum +from typing import List, Optional, Dict +from pydantic import BaseModel + + +class AnalystType(str, Enum): + MARKET = "market" + SOCIAL = "social" + NEWS = "news" + FUNDAMENTALS = "fundamentals" diff --git a/cli/static/welcome.txt b/cli/static/welcome.txt new file mode 100644 index 0000000..f2cf641 --- /dev/null +++ b/cli/static/welcome.txt @@ -0,0 +1,7 @@ + + ______ ___ ___ __ + /_ __/________ _____/ (_)___ ____ _/ | ____ ____ ____ / /______ + / / / ___/ __ `/ __ / / __ \/ __ `/ /| |/ __ `/ _ \/ __ \/ __/ ___/ + / / / / / /_/ / /_/ / / / / / /_/ / ___ / /_/ / __/ / / / /_(__ ) +/_/ /_/ \__,_/\__,_/_/_/ /_/\__, /_/ |_\__, /\___/_/ /_/\__/____/ + /____/ /____/ diff --git a/cli/utils.py b/cli/utils.py new file mode 100644 index 0000000..c386525 --- /dev/null +++ b/cli/utils.py @@ -0,0 +1,195 @@ +import questionary +from typing import List, Optional, Tuple, Dict + +from cli.models import AnalystType + +ANALYST_ORDER = [ + ("Market Analyst", AnalystType.MARKET), + ("Social Media Analyst", AnalystType.SOCIAL), + ("News Analyst", AnalystType.NEWS), + ("Fundamentals Analyst", AnalystType.FUNDAMENTALS), +] + + +def get_ticker() -> str: + """Prompt the user to enter a ticker symbol.""" + ticker = questionary.text( + "Enter the ticker symbol to analyze:", + validate=lambda x: len(x.strip()) > 0 or "Please enter a valid ticker symbol.", + style=questionary.Style( + [ + ("text", "fg:green"), + ("highlighted", "noinherit"), + ] + ), + ).ask() + + if not ticker: + console.print("\n[red]No ticker symbol provided. Exiting...[/red]") + exit(1) + + return ticker.strip().upper() + + +def get_analysis_date() -> str: + """Prompt the user to enter a date in YYYY-MM-DD format.""" + import re + from datetime import datetime + + def validate_date(date_str: str) -> bool: + if not re.match(r"^\d{4}-\d{2}-\d{2}$", date_str): + return False + try: + datetime.strptime(date_str, "%Y-%m-%d") + return True + except ValueError: + return False + + date = questionary.text( + "Enter the analysis date (YYYY-MM-DD):", + validate=lambda x: validate_date(x.strip()) + or "Please enter a valid date in YYYY-MM-DD format.", + style=questionary.Style( + [ + ("text", "fg:green"), + ("highlighted", "noinherit"), + ] + ), + ).ask() + + if not date: + console.print("\n[red]No date provided. Exiting...[/red]") + exit(1) + + return date.strip() + + +def select_analysts() -> List[AnalystType]: + """Select analysts using an interactive checkbox.""" + choices = questionary.checkbox( + "Select Your [Analysts Team]:", + choices=[ + questionary.Choice(display, value=value) for display, value in ANALYST_ORDER + ], + instruction="\n- Press Space to select/unselect analysts\n- Press 'a' to select/unselect all\n- Press Enter when done", + validate=lambda x: len(x) > 0 or "You must select at least one analyst.", + style=questionary.Style( + [ + ("checkbox-selected", "fg:green"), + ("selected", "fg:green noinherit"), + ("highlighted", "noinherit"), + ("pointer", "noinherit"), + ] + ), + ).ask() + + if not choices: + console.print("\n[red]No analysts selected. Exiting...[/red]") + exit(1) + + return choices + + +def select_research_depth() -> int: + """Select research depth using an interactive selection.""" + + # Define research depth options with their corresponding values + DEPTH_OPTIONS = [ + ("Shallow - Quick research, few debate and strategy discussion rounds", 1), + ("Medium - Middle ground, moderate debate rounds and strategy discussion", 3), + ("Deep - Comprehensive research, in depth debate and strategy discussion", 5), + ] + + choice = questionary.select( + "Select Your [Research Depth]:", + choices=[ + questionary.Choice(display, value=value) for display, value in DEPTH_OPTIONS + ], + instruction="\n- Use arrow keys to navigate\n- Press Enter to select", + style=questionary.Style( + [ + ("selected", "fg:yellow noinherit"), + ("highlighted", "fg:yellow noinherit"), + ("pointer", "fg:yellow noinherit"), + ] + ), + ).ask() + + if choice is None: + console.print("\n[red]No research depth selected. Exiting...[/red]") + exit(1) + + return choice + + +def select_shallow_thinking_agent() -> str: + """Select shallow thinking llm engine using an interactive selection.""" + + # Define shallow thinking llm engine options with their corresponding model names + SHALLOW_AGENT_OPTIONS = [ + ("GPT-4o-mini - Fast and efficient for quick tasks", "gpt-4o-mini"), + ("GPT-4.1-nano - Ultra-lightweight model for basic operations", "gpt-4.1-nano"), + ("GPT-4.1-mini - Compact model with good performance", "gpt-4.1-mini"), + ("GPT-4o - Standard model with solid capabilities", "gpt-4o"), + ] + + choice = questionary.select( + "Select Your [Quick-Thinking LLM Engine]:", + choices=[ + questionary.Choice(display, value=value) + for display, value in SHALLOW_AGENT_OPTIONS + ], + instruction="\n- Use arrow keys to navigate\n- Press Enter to select", + style=questionary.Style( + [ + ("selected", "fg:magenta noinherit"), + ("highlighted", "fg:magenta noinherit"), + ("pointer", "fg:magenta noinherit"), + ] + ), + ).ask() + + if choice is None: + console.print( + "\n[red]No shallow thinking llm engine selected. Exiting...[/red]" + ) + exit(1) + + return choice + + +def select_deep_thinking_agent() -> str: + """Select deep thinking llm engine using an interactive selection.""" + + # Define deep thinking llm engine options with their corresponding model names + DEEP_AGENT_OPTIONS = [ + ("GPT-4.1-nano - Ultra-lightweight model for basic operations", "gpt-4.1-nano"), + ("GPT-4.1-mini - Compact model with good performance", "gpt-4.1-mini"), + ("GPT-4o - Standard model with solid capabilities", "gpt-4o"), + ("o4-mini - Specialized reasoning model (compact)", "o4-mini"), + ("o3-mini - Advanced reasoning model (lightweight)", "o3-mini"), + ("o3 - Full advanced reasoning model", "o3"), + ("o1 - Premier reasoning and problem-solving model", "o1"), + ] + + choice = questionary.select( + "Select Your [Deep-Thinking LLM Engine]:", + choices=[ + questionary.Choice(display, value=value) + for display, value in DEEP_AGENT_OPTIONS + ], + instruction="\n- Use arrow keys to navigate\n- Press Enter to select", + style=questionary.Style( + [ + ("selected", "fg:magenta noinherit"), + ("highlighted", "fg:magenta noinherit"), + ("pointer", "fg:magenta noinherit"), + ] + ), + ).ask() + + if choice is None: + console.print("\n[red]No deep thinking llm engine selected. Exiting...[/red]") + exit(1) + + return choice diff --git a/index_complete.html b/index_complete.html deleted file mode 100644 index a922c15..0000000 --- a/index_complete.html +++ /dev/null @@ -1,526 +0,0 @@ - - - - - - - - TradingAgents: Multi-Agents LLM Financial Trading Framework - - - - - - - - - - - - - - - - - - - - - - -
-
-
-
-
-

TradingAgents: Multi-Agents LLM Financial Trading Framework

-
- Yijia Xiao1, - - Edward Sun1, - Di Luo1,2, - Wei Wang1 -
-
- 1University of California, Los Angeles, - 2Massachusetts Institute of Technology -
-
- -
-
-
-
-
-
- -
-
-
-
-

Abstract

-
-

Significant progress has been made in automated problem-solving using societies of agents powered by large language models (LLMs). In finance, efforts have largely focused on single-agent systems handling specific tasks or multi-agent frameworks independently gathering data. However, multi-agent systems' potential to replicate real-world trading firms' collaborative dynamics remains underexplored. TradingAgents proposes a novel stock trading framework inspired by trading firms, featuring LLM-powered agents in specialized roles such as fundamental analysts, sentiment analysts, technical analysts, and traders with varied risk profiles. The framework includes Bull and Bear researcher agents assessing market conditions, a risk management team monitoring exposure, and traders synthesizing insights from debates and historical data to make informed decisions. By simulating a dynamic, collaborative trading environment, this framework aims to improve trading performance. Detailed architecture and extensive experiments reveal its superiority over baseline models, with notable improvements in cumulative returns, Sharpe ratio, and maximum drawdown, highlighting the potential of multi-agent LLM frameworks in financial trading.

-
-
-
-
-
- -
-
-
-
-

Introduction

-
-

Autonomous agents leveraging Large Language Models (LLMs) present a transformative approach to decision-making by replicating human processes and workflows across various applications. These systems enhance the problem-solving capabilities of language agents by equipping them with tools and enabling collaboration with other agents, effectively breaking down complex problems into manageable components. One prominent application of these autonomous frameworks is in the financial market—a highly complex system influenced by numerous factors, including company fundamentals, market sentiment, technical indicators, and macroeconomic events.

- -

Traditional algorithmic trading systems often rely on quantitative models that struggle to fully capture the complex interplay of diverse factors. In contrast, LLMs excel at processing and understanding natural language data, making them particularly effective for tasks that require textual comprehension, such as analyzing news articles, financial reports, and social media sentiment. Additionally, deep learning-based trading systems often suffer from low explainability, as they rely on hidden features that drive decision-making but are difficult to interpret. Recent advancements in multi-agent LLM frameworks for finance have shown significant promise in addressing these challenges. These frameworks create explainable AI systems, where decisions are supported by evidence and transparent reasoning, demonstrating their potential in financial applications.

- -

Despite their potential, most current applications of language agents in the financial and trading sectors face two significant limitations:

- - Lack of Realistic Organizational Modeling: Many frameworks fail to capture the complex interactions between agents that mimic the structure of real-world trading firms. Instead, they focus narrowly on specific task performance, often disconnected from the organizational workflows and established human operating procedures proven effective in trading. This limits their ability to fully replicate and benefit from real-world trading practices. - - Inefficient Communication Interfaces: Most existing systems use natural language as the primary communication medium, typically relying on message histories or an unstructured pool of information for decision-making. This approach often results in a "telephone effect", where details are lost, and states become corrupted as conversations lengthen. Agents struggle to maintain context and track extended histories while filtering out irrelevant information from previous decision steps, diminishing their effectiveness in handling complex, dynamic tasks. Additionally, the unstructured pool-of-information approach lacks clear instructions, forcing logical communication and information exchange between agents to depend solely on retrieval, which disrupts the relational integrity of the data.

- -

In this work, we address these key limitations of existing models by introducing a system that overcomes these challenges. First, our framework bridges the gap by simulating the multi-agent decision-making processes typical of professional trading teams. It incorporates specialized agents tailored to distinct aspects of trading, inspired by the organizational structure of real-world trading firms. These agents include fundamental analysts, sentiment/news analysts, technical analysts, and traders with diverse risk profiles. Bullish and bearish debaters evaluate market conditions to provide balanced recommendations, while a risk management team ensures that exposures remain within acceptable limits. Second, to enhance communication, our framework combines structured outputs for control, clarity, and reasoning with natural language dialogue to facilitate effective debate and collaboration among agents. This hybrid approach ensures both precision and flexibility in decision-making.

- -

We validate our framework through experiments on historical financial data, comparing its performance against multiple baselines. Comprehensive evaluation metrics, including cumulative return, Sharpe ratio, and maximum drawdown, are employed to assess its overall effectiveness.

-
-
-
-
-
- -
-
-
-
-

Related Work

- -

LLMs as Financial Assistants

-
-

Large Language Models (LLMs) are applied in finance by fine-tuning on financial data or training on financial corpora. This improves the model’s understanding of financial terminology and data, enabling a specialized assistant for analytical support, insights, and information retrieval, rather than trade execution.

- - Fine-Tuned LLMs for Finance -

Fine-tuning enhances domain-specific performance. Examples include PIXIU (FinMA), which fine-tuned LLaMA on 136K finance-related instructions; FinGPT, which used LoRA to fine-tune models like LLaMA and ChatGLM with about 50K finance-specific samples; and Instruct-FinGPT, fine-tuned on 10K instruction samples from financial sentiment analysis datasets. These models outperform their base versions and other open-source LLMs like BLOOM and OPT in finance classification tasks, even surpassing BloombergGPT in several evaluations. However, in generative tasks, they perform similarly or slightly worse than powerful general-purpose models like GPT-4, indicating a need for more high-quality, domain-specific datasets.

- - Finance LLMs Trained from Scratch -

Training LLMs from scratch on finance-specific corpora aims for better domain adaptation. Models like BloombergGPT, XuanYuan 2.0, and Fin-T5 combine public datasets with finance-specific data during pretraining. BloombergGPT, for instance, was trained on both general and financial text, with proprietary Bloomberg data enhancing its performance on finance benchmarks. These models outperform general-purpose counterparts like BLOOM-176B and T5 in tasks such as market sentiment classification and summarization. While they may not match larger closed-source models like GPT-3 or PaLM, they offer competitive performance among similar-sized open-source models without compromising general language understanding.

- -

In summary, finance-specific LLMs developed through fine-tuning or training from scratch show significant improvements in domain-specific tasks, underscoring the importance of domain adaptation and the potential for further enhancements with high-quality finance-specific datasets.

- -
- TradingAgents Overall Framework Organization -
Figure 1: TradingAgents Overall Framework Organization. I. Analysts Team: Four analysts concurrently gather relevant market information. II. Research Team: The team discusses and evaluates the collected data. III. Trader: Based on the researchers' analysis, the trader makes the trading decision. IV. Risk Management Team: Risk guardians assess the decision against current market conditions to mitigate risks. V. Fund Manager: The fund manager approves and executes the trade.
-
-
- -

LLMs as Traders

-
-

LLMs act as trader agents making direct trading decisions by analyzing external data like news, financial reports, and stock prices. Proposed architectures include news-driven, reasoning-driven, and reinforcement learning (RL)-driven agents.

- - News-Driven Agents -

News-driven architectures integrate stock news and macroeconomic updates into LLM prompts to predict stock price movements. Studies evaluating both closed-source models (e.g., GPT-3.5, GPT-4) and open-source LLMs (e.g., Qwen, Baichuan) in financial sentiment analysis have shown the effectiveness of simple long-short strategies based on sentiment scores. Further research on fine-tuned LLMs like FinGPT and OPT demonstrates improved performance through domain-specific alignment. Advanced methods involve summarizing news data and reasoning about their relationship with stock prices.

- - Reasoning-Driven Agents -

Reasoning-driven agents enhance trading decisions through mechanisms like reflection and debate. Reflection-driven agents, such as FinMem and FinAgent, use layered memorization and multimodal data to summarize inputs into memories, inform decisions, and incorporate technical indicators, achieving superior backtest performance while mitigating hallucinations. Debate-driven agents, like those in heterogeneous frameworks and TradingGPT, enhance reasoning and factual validity by employing LLM debates among agents with different roles, improving sentiment classification and increasing robustness in trading decisions.

- - Reinforcement Learning-Driven Agents -

Reinforcement learning methods align LLM outputs with expected behaviors, using backtesting as rewards. SEP employs RL with memorization and reflection to refine LLM predictions based on market history. Classical RL methods are also used in trading frameworks that integrate LLM-generated embeddings with stock features, trained via algorithms like Proximal Policy Optimization (PPO).

-
- -

LLMs as Alpha Miners

-
-

LLMs are also used to generate alpha factors instead of making direct trading decisions. QuantAgent demonstrates this by leveraging LLMs to produce alpha factors through an inner-loop and outer-loop architecture. In the inner loop, a writer agent generates a script from a trader's idea, while a judge agent provides feedback. In the outer loop, the code is tested in the real market, and trading results enhance the judge agent. This approach enables progressive approximation of optimal behavior.

- -

Subsequent research, such as AlphaGPT, proposes a human-in-the-loop framework for alpha mining with a similar architecture. Both studies showcase the effectiveness of LLM-powered alpha mining systems, highlighting their potential in automating and accelerating the development of trading strategies by generating and refining alpha factors.

-
-
-
-
-
- -
-
-
-
-

TradingAgents: Role Specialization

-
-

Assigning LLM agents clear, well-defined roles with specific goals enables the breakdown of complex objectives into smaller, manageable subtasks. Financial trading is a prime example of such complexity, demanding the integration of diverse signals, inputs, and specialized expertise. In the real world, this approach to managing complexity is demonstrated by trading firms that rely on expert teams to collaborate and make high-stakes decisions, underscoring the multifaceted nature of the task.

- -

In a typical trading firm, vast amounts of data are collected, including financial metrics, price movements, trading volumes, historical performance, economic indicators, and news sentiment. This data is then analyzed by quantitative experts (quants), including mathematicians, data scientists, and engineers, using advanced tools and algorithms to identify trends and predict market movements.

- -

Inspired by this organizational structure, TradingAgents defines seven distinct agent roles within a simulated trading firm: Fundamentals Analyst, Sentiment Analyst, News Analyst, Technical Analyst, Researcher, Trader, and Risk Manager. Each agent is assigned a specific name, role, goal, and set of constraints, alongside predefined context, skills, and tools tailored to their function. For example, a Sentiment Analyst is equipped with tools like web search engines, Reddit search APIs, X/Twitter search tools, and sentiment score calculation algorithms, while a Technical Analyst can execute code, calculate technical indicators, and analyze trading patterns. More specifically, TradingAgents assumes the following teams.

- -

Analyst Team

-
-

The Analyst Team (Figure 2) is composed of specialized agents responsible for gathering and analyzing various types of market data to inform trading decisions. Each agent focuses on a specific aspect of market analysis, bringing together a comprehensive view of the market's conditions.

- -
- TradingAgents Analyst Team -
Figure 2: TradingAgents Analyst Team
-
- -
    -
  • Fundamental Analyst Agents: These agents evaluate company fundamentals by analyzing financial statements, earnings reports, insider transactions, and other pertinent data. They assess a company's intrinsic value to identify undervalued or overvalued stocks, providing insights into long-term investment potential.
  • -
  • Sentiment Analyst Agents: These agents process large volumes of social media posts, sentiment scores, and insider sentiments derived from public information and social media activity. They gauge market sentiment to predict how collective investor behavior might impact stock prices in the short term.
  • -
  • News Analyst Agents: These agents analyze news articles, government announcements, and other macroeconomic indicators to assess the market's macroeconomic state, major world events, and significant company changes. They identify news events that could influence market movements, helping to anticipate sudden shifts in market dynamics.
  • -
  • Technical Analyst Agents: These agents calculate and select relevant technical indicators, such as Moving Average Convergence Divergence (MACD) and Relative Strength Index (RSI), customized for specific assets. They analyze price patterns and trading volumes to forecast future price movements, assisting in timing entry and exit points.
  • -
- -

Collectively, the Analyst Team synthesizes data from multiple sources to provide a holistic market analysis. Their combined insights form the foundational input for the Researcher Team, ensuring that all facets of the market are considered in subsequent decision-making processes.

-
- -

Researcher Team

-
-

The Researcher Team (Figure 3) is responsible for critically evaluating the information provided by the Analyst Team. Comprised of agents adopting both bullish and bearish perspectives, they engage in multiple rounds of debate to assess the potential risks and benefits of investment decisions.

- -
-
-
- TradingAgents Researcher Team -
Figure 3: TradingAgents Researcher Team: Bullish Perspectives and Bearish Perspectives
-
-
-
-
- TradingAgents Trader Decision-Making Process -
Figure 4: TradingAgents Trader Decision-Making Process
-
-
-
-
- TradingAgents Risk Management Team and Fund Manager Approval Workflow -
Figure 5: TradingAgents Risk Management Team and Fund Manager Approval Workflow
-
-
-
- -
    -
  • Bullish Researchers: These agents advocate for investment opportunities by highlighting positive indicators, growth potential, and favorable market conditions. They construct arguments supporting the initiation or continuation of positions in certain assets.
  • -
  • Bearish Researchers: Conversely, these agents focus on potential downsides, risks, and unfavorable market signals. They provide cautionary insights, questioning the viability of investment strategies and highlighting possible negative outcomes.
  • -
- -

Through this dialectical process, the Researcher Team aims to reach a balanced understanding of the market situation. Their thorough analysis helps in identifying the most promising investment strategies while anticipating possible challenges, thus aiding the Trader Agents in making informed decisions.

-
- -

Trader Agents

-
-

Trader Agents (Figure 4) are responsible for executing trading decisions based on the comprehensive analysis provided by the Analyst Team and the nuanced perspectives from the Researcher Team. They assess the synthesized information, considering both quantitative data and qualitative insights, to determine optimal trading actions.

- -
    -
  • Evaluating recommendations and insights from analysts and researchers.
  • -
  • Deciding on the timing and size of trades to maximize trading returns.
  • -
  • Placing buy or sell orders in the market.
  • -
  • Adjusting portfolio allocations in response to market changes and new information.
  • -
- -

Trader Agents must balance potential returns against associated risks, making timely decisions in a dynamic market environment. Their actions directly impact the firm's performance, necessitating a high level of precision and strategic thinking.

-
- -

Risk Management Team

-
-

The Risk Management Team (Figure 5) monitors and controls the firm's exposure to various market risks. These agents continuously evaluate the portfolio's risk profile, ensuring that trading activities remain within predefined risk parameters and comply with regulatory requirements.

- -
    -
  • Assessing factors such as market volatility, liquidity, and counterparty risks.
  • -
  • Implementing risk mitigation strategies, such as setting stop-loss orders or diversifying holdings.
  • -
  • Providing feedback to Trader Agents on risk exposures and suggesting adjustments to trading strategies.
  • -
  • Ensuring that the overall portfolio aligns with the firm's risk tolerance and investment objectives.
  • -
- -

By offering oversight and guidance, the Risk Management Team helps maintain the firm's financial stability and protect against adverse market events. They play a crucial role in safeguarding assets and ensuring sustainable long-term performance.

- -

All agents in TradingAgents follow the ReAct prompting framework, which synergizes reasoning and acting. The environment state is shared and monitored by the agents, enabling them to take context-appropriate actions such as conducting research, executing trades, engaging in debates, or managing risks. This design ensures a collaborative, dynamic decision-making process reflective of real-world trading systems.

-
-
-
-
-
-
- -
-
-
-
-

TradingAgents: Agent Workflow

-
-

Communication Protocol

-

Most existing LLM-based agent frameworks use natural language as the primary communication interface, typically through structured message histories or collections of agent-generated messages. However, relying solely on natural language often proves insufficient for solving complex, long-term tasks that require extensive planning horizons. In such cases, pure natural language communication can resemble a game of telephone—over multiple iterations, initial information may be forgotten or distorted due to context length limitations and an overload of text that obscures critical earlier details. To address this limitation, we draw inspiration from frameworks like MetaGPT, which adopt a structured approach to communication. Our model introduces a structured communication protocol to govern agent interactions. By clearly defining each agent's state, we ensure that each role only extracts or queries the necessary information, processes it, and returns a completed report. This streamlined approach reduces unnecessary steps, lowers the risk of message corruption, and keeps interactions focused and efficient, even in complex, long-horizon tasks.

- -

Types of Agent Interactions

-

In contrast to previous multi-agent trading frameworks, which rely heavily on natural language dialogue, TradingAgents agents communicate primarily through structured documents and diagrams. These documents encapsulate the agents' insights in concise, well-organized reports that preserve essential content while avoiding irrelevant information. By utilizing structured reports, agents can query necessary details directly from the global state, eliminating the need for lengthy conversations that risk diluting information, extending the message state indefinitely, and causing data loss. The types of documents and the information they contain are detailed below:

- -
    -
  • Analyst Team: Fundamental, sentiment, news, and technical analysts compile their research and findings into concise analysis reports specific to their areas of expertise. These reports include key metrics, insights, and recommendations based on their specialized analyses.
  • -
  • Traders: Traders review and analyze the reports from the analysts, carefully deliberating to produce clear decision signals. They accompany these decisions with detailed reports explaining their rationale and supporting evidence, which are later utilized by the risk management team.
  • -
- -

Agents engage in natural language dialogue exclusively during agent-to-agent conversations and debates. These concise, focused discussions have been shown to promote deeper reasoning and integrate diverse perspectives, enabling more balanced decisions in complex, long-horizon scenarios—a method particularly relevant to the intricate environment of trading. This approach seamlessly integrates with our structured framework, as the conversation state is recorded as a structured entry within the overall agent state. The types of communication in these scenarios are detailed below:

- -
    -
  • Researcher Team: Each researcher agent queries the global agent state for analyst reports and carefully forms their opinion. Two researchers represent opposing perspectives: one bullish and one bearish. They engage in natural language dialogue for $n$ rounds, as determined by the debate facilitator agent. At the conclusion, the facilitator reviews the debate history, selects the prevailing perspective, and records it as a structured entry in the communication protocol.
  • -
  • Risk Management Team: The risk management team, similar to the researcher team, queries the trader's decision and accompanying report. They then deliberate from three perspectives—risk-seeking, neutral, and risk-conservative—to adjust the trading plan within risk constraints. They engage in $n$ rounds of natural language discussion, guided by a facilitator agent.
  • -
  • Fund Manager: The fund manager reviews the discussion from the risk management team, determines the appropriate risk adjustments, and updates the trader's decision and report states within the communication protocol.
  • -
- -

Backbone LLMs

-

To meet the diverse complexity and speed demands of tasks in our framework, we strategically select Large Language Models (LLMs) based on their strengths. Quick-thinking models, such as gpt-4o-mini and gpt-4o, efficiently handle fast, low-depth tasks like summarization, data retrieval, and converting tabular data to text. In contrast, deep-thinking models like o1-preview excel in reasoning-intensive tasks such as decision-making, evidence-based report writing, and data analysis. These models leverage their architectures for multi-round reasoning, producing logically sound, in-depth insights. Additionally, we prioritize models with proven reliability and scalability to ensure optimal performance across various market conditions. We also employ auxiliary expert models for specialized tasks like sentiment analysis.

- -

Specifically, all analyst nodes rely on deep-thinking models to ensure robust analysis, while quick-thinking models handle data retrieval from APIs and tools for efficiency. Researchers and traders use deep-thinking models to generate valuable insights and support well-informed decisions. By aligning the choice of LLMs with the specific requirements of each task, our framework achieves a balance between efficiency and depth of reasoning, which is crucial for effective trading strategies.

- -

This implementation strategy ensures that TradingAgents can be deployed without requiring a GPU, relying only on API credits. It also introduces seamless exchangeability of backbone models, enabling researchers to effortlessly replace the model with any locally hosted or API-accessible alternatives in the future. This adaptability supports the integration of improved reasoning models or finance-tuned models customized for specific tasks. As a result, TradingAgents is highly scalable and future-proof, offering flexibility to accommodate any backbone model for any of its agents.

-
-
-
-
-
- -
-
-
-
-

Experiments

-
-

In this section, we describe the experimental setup used to evaluate our proposed framework. We also provide detailed descriptions of the evaluation metrics employed to assess performance comprehensively.

- -

Back Trading

-

To simulate a realistic trading environment, we utilize a multi-asset and multi-modal financial dataset comprising of various stocks such as Apple, Nvidia, Microsoft, Meta, Google, and more. The dataset includes:

- -
    -
  • Historical Stock Prices: Open, high, low, close, volume, and adjusted close prices from January 1st, 2024, to March 29th, 2024.
  • -
  • News Articles: Daily news updates are gathered from diverse sources such as Bloomberg, Yahoo, EODHD, FinnHub, and Reddit, covering specific company developments, global events, macroeconomic trends, and government updates.
  • -
  • Social Media Posts and Sentiment: Posts from Reddit, X/Twitter, and other platforms along with sentiment scores of posts calculated by auxiliary language models.
  • -
  • Insider Sentiments and Transactions: Sentiment derived from public information, including transactions from SEDI and relevant company filings.
  • -
  • Financial Statements and Earnings Reports: Quarterly and annual reports filed by companies.
  • -
  • Company Profiles and Financial History: Descriptions of company profiles, target industries, and financial history reported by third parties.
  • -
  • Technical Indicators: Sixty standard technical analysis indicators calculated for each asset, including MACD, RSI, Bollinger Bands, etc.
  • -
- -

Simulation Setup

-

We simulate the trading environment for the period from June 19, 2024, to November 19, 2024. TradingAgents facilitates seamless plug-and-play strategies during the simulation, enabling straightforward comparisons with any baseline. Agents make decisions based solely on data available up to each trading day, ensuring no future data is used (eliminating look-ahead bias). Based on their analysis, TradingAgents generates trading signals to buy, sell, or hold assets, which are then executed. Afterward, analysis metrics are calculated before proceeding to the next day's data.

- -

Baseline Models

-

We compare our TradingAgents framework against several baselines:

- -
    -
  • Buy and Hold: Investing equal amounts in all selected stocks and holding them throughout the simulation period.
  • -
  • MACD (Moving Average Convergence Divergence): A trend-following momentum strategy that generates buy and sell signals based on the crossover points between the MACD line and signal line.
  • -
  • KDJ and RSI (Relative Strength Index): A momentum strategy combining KDJ (stochastic oscillator) and RSI (relative strength index) indicators to identify overbought and oversold conditions for trading signals.
  • -
  • ZMR (Zero Mean Reversion): A mean reversion trading strategy that generates signals based on price deviations from and subsequent reversions to a zero reference line.
  • -
  • SMA (Simple Moving Average): A trend-following strategy that generates trading signals based on crossovers between short-term and long-term moving averages.
  • -
- -

Evaluation Metrics

- -
-
-
- Cumulative Returns on AAPL -
(a) Cumulative Returns on AAPL
-
-
- -
-
- TradingAgents Transactions for AAPL -
- (b) TradingAgents Transactions for AAPL.
- Green / Red Arrows for Long / Short Positions. -
-
-
-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CategoriesModelsAAPLGOOGLAMZN
CR%↑ARR%↑SR↑MDD%↓CR%↑ARR%↑SR↑MDD%↓CR%↑ARR%↑SR↑MDD%↓
MarketB&H-5.23-5.09-1.2911.907.788.091.3513.0417.117.63.533.80
Rule-basedMACD-1.49-1.48-0.814.536.206.262.311.22----
KDJ&RSI2.052.071.641.090.40.40.021.58-0.77-0.76-2.251.08
ZMR0.570.570.170.86-0.580.582.122.34-0.77-0.77-2.450.82
SMA-3.2-2.97-1.723.676.236.432.122.3411.0111.62.223.97
OursTradingAgents26.6230.58.210.9124.3627.586.391.6923.2124.905.602.11
Improvement(%)24.5728.436.57-16.5819.494.26-6.107.302.07-
-

Table 1: TradingAgents: Comparison of Performance Metrics across AAPL, GOOGL, and AMZN.

- -

Sharpe Ratio

-

The Sharpe Ratio performance highlights TradingAgents' exceptional ability to deliver superior risk-adjusted returns, consistently outperforming all baseline models across AAPL, GOOGL, and AMZN with Sharpe Ratios of at least 5.60—surpassing the next best models by a significant margin of at least 2.07 points. This result underscores TradingAgents' effectiveness in balancing returns against risk, a critical metric for sustainable and predictable investment growth. By excelling over market benchmarks like Buy-and-Hold and advanced strategies such as KDJRSI, SMA, MACD, and ZMR, TradingAgents demonstrates its adaptability and robustness in diverse market conditions. Its ability to maximize returns while maintaining controlled risk exposure establishes a solid foundation for multi-agent and debate-based automated trading algorithms.

- -

Maximum Drawdown

-

While rule-based baselines demonstrated superior performance in controlling risk, as reflected by their maximum drawdown scores, they fell short in capturing high returns. This trade-off between risk and reward underscores TradingAgents' strength as a balanced approach. Despite higher returns being typically associated with higher risks, TradingAgents maintained a relatively low maximum drawdown compared to many baselines. Its effective risk-control mechanisms, facilitated by the debates among risk-control agents, ensured that the maximum drawdown remained within a manageable limit, not exceeding 2%. This demonstrates TradingAgents' capability to strike a robust balance between maximizing returns and managing risk effectively.

- -

Explainability

-

A significant drawback of current deep learning methods for trading is their dense and complex architectures, which often render the decisions made by trading agents indecipherable to humans. This challenge, rooted in the broader issue of AI explainability, is particularly critical for trading agents, as they operate in real-world financial markets, often involving substantial sums of money where incorrect decisions can lead to severe consequences and losses.

- -

In contrast, an LLM-based agentic framework for trading offers a transformative advantage: its operations and decisions are communicated in natural language, making them highly interpretable to humans. To illustrate this, we provide the full trading log of TradingAgents for a single day in the Appendix, showcasing its use of the ReAct-style prompting framework. Each decision made by the agents is accompanied by detailed reasoning, tool usage, and thought processes, enabling traders to easily understand and debug the system. This transparency empowers traders to fine-tune and adjust the framework to account for factors influencing decisions, offering a significant edge in explainability over traditional deep-learning trading algorithms.

-
-
-
-
-
- -
-
-
-
-

Conclusion

-
-

In this paper, we introduced TradingAgents, an LLM-agent-powered stock trading framework that simulates a realistic trading firm environment with multiple specialized agents engaging in agentic debates and conversations. Leveraging the capabilities of LLMs to process and analyze diverse data sources, the framework enables informed trading decisions while utilizing multi-agent interactions to enhance performance through comprehensive reasoning and debate before acting. By integrating agents with distinct roles and risk profiles, along with a reflective agent and a dedicated risk management team, TradingAgents significantly improves trading outcomes and risk management compared to baseline models. Additionally, the collaborative nature of these agents ensures adaptability to varying market conditions. Extensive experiments demonstrate that TradingAgents outperforms traditional trading strategies and baselines in cumulative return, Sharpe ratio, and other critical metrics. Future work will focus on deploying the framework in a live trading environment, expanding agent roles, and incorporating real-time data processing to enhance performance further.

-
-
-
-
-
- - - - - diff --git a/main.py b/main.py new file mode 100644 index 0000000..c78cd6e --- /dev/null +++ b/main.py @@ -0,0 +1,19 @@ +from tradingagents.graph.trading_graph import TradingAgentsGraph +from tradingagents.default_config import DEFAULT_CONFIG + +# Create a custom config +config = DEFAULT_CONFIG.copy() +config["deep_think_llm"] = "gpt-4.1-nano" # Use a different model +config["quick_think_llm"] = "gpt-4.1-nano" # Use a different model +config["max_debate_rounds"] = 1 # Increase debate rounds +config["online_tools"] = True # Increase debate rounds + +# Initialize with custom config +ta = TradingAgentsGraph(debug=True, config=config) + +# forward propagate +_, decision = ta.propagate("NVDA", "2024-05-10") +print(decision) + +# Memorize mistakes and reflect +# ta.reflect_and_remember(1000) # parameter is the position returns diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..1c7c281 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,24 @@ +typing-extensions +langchain-openai +langchain-experimental +pandas +yfinance +praw +feedparser +stockstats +eodhd +langgraph +chromadb +setuptools +backtrader +akshare +tushare +finnhub-python +parsel +requests +tqdm +pytz +redis +chainlit +rich +questionary diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..793df3e --- /dev/null +++ b/setup.py @@ -0,0 +1,43 @@ +""" +Setup script for the TradingAgents package. +""" + +from setuptools import setup, find_packages + +setup( + name="tradingagents", + version="0.1.0", + description="Multi-Agents LLM Financial Trading Framework", + author="TradingAgents Team", + author_email="yijia.xiao@cs.ucla.edu", + url="https://github.com/TauricResearch", + packages=find_packages(), + install_requires=[ + "langchain>=0.1.0", + "langchain-openai>=0.0.2", + "langchain-experimental>=0.0.40", + "langgraph>=0.0.20", + "numpy>=1.24.0", + "pandas>=2.0.0", + "praw>=7.7.0", + "stockstats>=0.5.4", + "yfinance>=0.2.31", + "typer>=0.9.0", + "rich>=13.0.0", + "questionary>=2.0.1", + ], + python_requires=">=3.10", + entry_points={ + "console_scripts": [ + "tradingagents=cli.main:app", + ], + }, + classifiers=[ + "Development Status :: 3 - Alpha", + "Intended Audience :: Financial and Trading Industry", + "License :: OSI Approved :: Apache Software License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Topic :: Office/Business :: Financial :: Investment", + ], +) diff --git a/tradingagents/agents/__init__.py b/tradingagents/agents/__init__.py new file mode 100644 index 0000000..6f50765 --- /dev/null +++ b/tradingagents/agents/__init__.py @@ -0,0 +1,41 @@ +from .utils.agent_utils import Toolkit, create_msg_delete +from .utils.agent_states import AgentState, InvestDebateState, RiskDebateState +from .utils.memory import FinancialSituationMemory + +from .analysts.fundamentals_analyst import create_fundamentals_analyst +from .analysts.market_analyst import create_market_analyst +from .analysts.news_analyst import create_news_analyst +from .analysts.social_media_analyst import create_social_media_analyst + +from .researchers.bear_researcher import create_bear_researcher +from .researchers.bull_researcher import create_bull_researcher + +from .risk_mgmt.aggresive_debator import create_risky_debator +from .risk_mgmt.conservative_debator import create_safe_debator +from .risk_mgmt.neutral_debator import create_neutral_debator + +from .managers.research_manager import create_research_manager +from .managers.risk_manager import create_risk_manager + +from .trader.trader import create_trader + +__all__ = [ + "FinancialSituationMemory", + "Toolkit", + "AgentState", + "create_msg_delete", + "InvestDebateState", + "RiskDebateState", + "create_bear_researcher", + "create_bull_researcher", + "create_research_manager", + "create_fundamentals_analyst", + "create_market_analyst", + "create_neutral_debator", + "create_news_analyst", + "create_risky_debator", + "create_risk_manager", + "create_safe_debator", + "create_social_media_analyst", + "create_trader", +] diff --git a/tradingagents/agents/analysts/fundamentals_analyst.py b/tradingagents/agents/analysts/fundamentals_analyst.py new file mode 100644 index 0000000..45ddb91 --- /dev/null +++ b/tradingagents/agents/analysts/fundamentals_analyst.py @@ -0,0 +1,59 @@ +from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder +import time +import json + + +def create_fundamentals_analyst(llm, toolkit): + def fundamentals_analyst_node(state): + current_date = state["trade_date"] + ticker = state["company_of_interest"] + company_name = state["company_of_interest"] + + if toolkit.config["online_tools"]: + tools = [toolkit.get_fundamentals_openai] + else: + tools = [ + toolkit.get_finnhub_company_insider_sentiment, + toolkit.get_finnhub_company_insider_transactions, + toolkit.get_simfin_balance_sheet, + toolkit.get_simfin_cashflow, + toolkit.get_simfin_income_stmt, + ] + + system_message = ( + "You are a researcher tasked with analyzing fundamental information over the past week about a company. Please write a comprehensive report of the company's fundamental information such as financial documents, company profile, basic company financials, company financial history, insider sentiment and insider transactions to gain a full view of the company's fundamental information to inform traders. Make sure to include as much detail as possible. Do not simply state the trends are mixed, provide detailed and finegrained analysis and insights that may help traders make decisions." + + " Make sure to append a Makrdown table at the end of the report to organize key points in the report, organized and easy to read.", + ) + + prompt = ChatPromptTemplate.from_messages( + [ + ( + "system", + "You are a helpful AI assistant, collaborating with other assistants." + " Use the provided tools to progress towards answering the question." + " If you are unable to fully answer, that's OK; another assistant with different tools" + " will help where you left off. Execute what you can to make progress." + " If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable," + " prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop." + " You have access to the following tools: {tool_names}.\n{system_message}" + "For your reference, the current date is {current_date}. The company we want to look at is {ticker}", + ), + MessagesPlaceholder(variable_name="messages"), + ] + ) + + prompt = prompt.partial(system_message=system_message) + prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools])) + prompt = prompt.partial(current_date=current_date) + prompt = prompt.partial(ticker=ticker) + + chain = prompt | llm.bind_tools(tools) + + result = chain.invoke(state["messages"]) + + return { + "messages": [result], + "fundamentals_report": result.content, + } + + return fundamentals_analyst_node diff --git a/tradingagents/agents/analysts/market_analyst.py b/tradingagents/agents/analysts/market_analyst.py new file mode 100644 index 0000000..4a18761 --- /dev/null +++ b/tradingagents/agents/analysts/market_analyst.py @@ -0,0 +1,84 @@ +from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder +import time +import json + + +def create_market_analyst(llm, toolkit): + + def market_analyst_node(state): + current_date = state["trade_date"] + ticker = state["company_of_interest"] + company_name = state["company_of_interest"] + + if toolkit.config["online_tools"]: + tools = [ + toolkit.get_YFin_data_online, + toolkit.get_stockstats_indicators_report_online, + ] + else: + tools = [ + toolkit.get_YFin_data, + toolkit.get_stockstats_indicators_report, + ] + + system_message = ( + """You are a trading assistant tasked with analyzing financial markets. Your role is to select the **most relevant indicators** for a given market condition or trading strategy from the following list. The goal is to choose up to **8 indicators** that provide complementary insights without redundancy. Categories and each category's indicators are: + +Moving Averages: +- close_50_sma: 50 SMA: A medium-term trend indicator. Usage: Identify trend direction and serve as dynamic support/resistance. Tips: It lags price; combine with faster indicators for timely signals. +- close_200_sma: 200 SMA: A long-term trend benchmark. Usage: Confirm overall market trend and identify golden/death cross setups. Tips: It reacts slowly; best for strategic trend confirmation rather than frequent trading entries. +- close_10_ema: 10 EMA: A responsive short-term average. Usage: Capture quick shifts in momentum and potential entry points. Tips: Prone to noise in choppy markets; use alongside longer averages for filtering false signals. + +MACD Related: +- macd: MACD: Computes momentum via differences of EMAs. Usage: Look for crossovers and divergence as signals of trend changes. Tips: Confirm with other indicators in low-volatility or sideways markets. +- macds: MACD Signal: An EMA smoothing of the MACD line. Usage: Use crossovers with the MACD line to trigger trades. Tips: Should be part of a broader strategy to avoid false positives. +- macdh: MACD Histogram: Shows the gap between the MACD line and its signal. Usage: Visualize momentum strength and spot divergence early. Tips: Can be volatile; complement with additional filters in fast-moving markets. + +Momentum Indicators: +- rsi: RSI: Measures momentum to flag overbought/oversold conditions. Usage: Apply 70/30 thresholds and watch for divergence to signal reversals. Tips: In strong trends, RSI may remain extreme; always cross-check with trend analysis. + +Volatility Indicators: +- boll: Bollinger Middle: A 20 SMA serving as the basis for Bollinger Bands. Usage: Acts as a dynamic benchmark for price movement. Tips: Combine with the upper and lower bands to effectively spot breakouts or reversals. +- boll_ub: Bollinger Upper Band: Typically 2 standard deviations above the middle line. Usage: Signals potential overbought conditions and breakout zones. Tips: Confirm signals with other tools; prices may ride the band in strong trends. +- boll_lb: Bollinger Lower Band: Typically 2 standard deviations below the middle line. Usage: Indicates potential oversold conditions. Tips: Use additional analysis to avoid false reversal signals. +- atr: ATR: Averages true range to measure volatility. Usage: Set stop-loss levels and adjust position sizes based on current market volatility. Tips: It's a reactive measure, so use it as part of a broader risk management strategy. + +Volume-Based Indicators: +- vwma: VWMA: A moving average weighted by volume. Usage: Confirm trends by integrating price action with volume data. Tips: Watch for skewed results from volume spikes; use in combination with other volume analyses. + +- Select indicators that provide diverse and complementary information. Avoid redundancy (e.g., do not select both rsi and stochrsi). Also briefly explain why they are suitable for the given market context. When you tool call, please use the exact name of the indicators provided above as they are defined parameters, otherwise your call will fail. Please make sure to call get_YFin_data first to retrieve the CSV that is needed to generate indicators. Write a very detailed and nuanced report of the trends you observe. Do not simply state the trends are mixed, provide detailed and finegrained analysis and insights that may help traders make decisions.""" + + """ Make sure to append a Markdown table at the end of the report to organize key points in the report, organized and easy to read.""" + ) + + prompt = ChatPromptTemplate.from_messages( + [ + ( + "system", + "You are a helpful AI assistant, collaborating with other assistants." + " Use the provided tools to progress towards answering the question." + " If you are unable to fully answer, that's OK; another assistant with different tools" + " will help where you left off. Execute what you can to make progress." + " If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable," + " prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop." + " You have access to the following tools: {tool_names}.\n{system_message}" + "For your reference, the current date is {current_date}. The company we want to look at is {ticker}", + ), + MessagesPlaceholder(variable_name="messages"), + ] + ) + + prompt = prompt.partial(system_message=system_message) + prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools])) + prompt = prompt.partial(current_date=current_date) + prompt = prompt.partial(ticker=ticker) + + chain = prompt | llm.bind_tools(tools) + + result = chain.invoke(state["messages"]) + + return { + "messages": [result], + "market_report": result.content, + } + + return market_analyst_node diff --git a/tradingagents/agents/analysts/news_analyst.py b/tradingagents/agents/analysts/news_analyst.py new file mode 100644 index 0000000..12222f5 --- /dev/null +++ b/tradingagents/agents/analysts/news_analyst.py @@ -0,0 +1,55 @@ +from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder +import time +import json + + +def create_news_analyst(llm, toolkit): + def news_analyst_node(state): + current_date = state["trade_date"] + ticker = state["company_of_interest"] + + if toolkit.config["online_tools"]: + tools = [toolkit.get_global_news_openai, toolkit.get_google_news] + else: + tools = [ + toolkit.get_finnhub_news, + toolkit.get_reddit_news, + toolkit.get_google_news, + ] + + system_message = ( + "You are a news researcher tasked with analyzing recent news and trends over the past week. Please write a comprehensive report of the current state of the world that is relevant for trading and macroeconomics. Look at news from EODHD, and finnhub to be comprehensive. Do not simply state the trends are mixed, provide detailed and finegrained analysis and insights that may help traders make decisions." + + """ Make sure to append a Makrdown table at the end of the report to organize key points in the report, organized and easy to read.""" + ) + + prompt = ChatPromptTemplate.from_messages( + [ + ( + "system", + "You are a helpful AI assistant, collaborating with other assistants." + " Use the provided tools to progress towards answering the question." + " If you are unable to fully answer, that's OK; another assistant with different tools" + " will help where you left off. Execute what you can to make progress." + " If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable," + " prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop." + " You have access to the following tools: {tool_names}.\n{system_message}" + "For your reference, the current date is {current_date}. We are looking at the company {ticker}", + ), + MessagesPlaceholder(variable_name="messages"), + ] + ) + + prompt = prompt.partial(system_message=system_message) + prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools])) + prompt = prompt.partial(current_date=current_date) + prompt = prompt.partial(ticker=ticker) + + chain = prompt | llm.bind_tools(tools) + result = chain.invoke(state["messages"]) + + return { + "messages": [result], + "news_report": result.content, + } + + return news_analyst_node diff --git a/tradingagents/agents/analysts/social_media_analyst.py b/tradingagents/agents/analysts/social_media_analyst.py new file mode 100644 index 0000000..42fb1f7 --- /dev/null +++ b/tradingagents/agents/analysts/social_media_analyst.py @@ -0,0 +1,55 @@ +from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder +import time +import json + + +def create_social_media_analyst(llm, toolkit): + def social_media_analyst_node(state): + current_date = state["trade_date"] + ticker = state["company_of_interest"] + company_name = state["company_of_interest"] + + if toolkit.config["online_tools"]: + tools = [toolkit.get_stock_news_openai] + else: + tools = [ + toolkit.get_reddit_stock_info, + ] + + system_message = ( + "You are a social media and company specific news researcher/analyst tasked with analyzing social media posts, recent company news, and public sentiment for a specific company over the past week. You will be given a company's name your objective is to write a comprehensive long report detailing your analysis, insights, and implications for traders and investors on this company's current state after looking at social media and what people are saying about that company, analyzing sentiment data of what people feel each day about the company, and looking at recent company news. Try to look at all sources possible from social media to sentiment to news. Do not simply state the trends are mixed, provide detailed and finegrained analysis and insights that may help traders make decisions." + + """ Make sure to append a Makrdown table at the end of the report to organize key points in the report, organized and easy to read.""", + ) + + prompt = ChatPromptTemplate.from_messages( + [ + ( + "system", + "You are a helpful AI assistant, collaborating with other assistants." + " Use the provided tools to progress towards answering the question." + " If you are unable to fully answer, that's OK; another assistant with different tools" + " will help where you left off. Execute what you can to make progress." + " If you or any other assistant has the FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** or deliverable," + " prefix your response with FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL** so the team knows to stop." + " You have access to the following tools: {tool_names}.\n{system_message}" + "For your reference, the current date is {current_date}. The current company we want to analyze is {ticker}", + ), + MessagesPlaceholder(variable_name="messages"), + ] + ) + + prompt = prompt.partial(system_message=system_message) + prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools])) + prompt = prompt.partial(current_date=current_date) + prompt = prompt.partial(ticker=ticker) + + chain = prompt | llm.bind_tools(tools) + + result = chain.invoke(state["messages"]) + + return { + "messages": [result], + "sentiment_report": result.content, + } + + return social_media_analyst_node diff --git a/tradingagents/agents/managers/research_manager.py b/tradingagents/agents/managers/research_manager.py new file mode 100644 index 0000000..c537fa2 --- /dev/null +++ b/tradingagents/agents/managers/research_manager.py @@ -0,0 +1,55 @@ +import time +import json + + +def create_research_manager(llm, memory): + def research_manager_node(state) -> dict: + history = state["investment_debate_state"].get("history", "") + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + investment_debate_state = state["investment_debate_state"] + + curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}" + past_memories = memory.get_memories(curr_situation, n_matches=2) + + past_memory_str = "" + for i, rec in enumerate(past_memories, 1): + past_memory_str += rec["recommendation"] + "\n\n" + + prompt = f"""As the portfolio manager and debate facilitator, your role is to critically evaluate this round of debate and make a definitive decision: align with the bear analyst, the bull analyst, or choose Hold only if it is strongly justified based on the arguments presented. + +Summarize the key points from both sides concisely, focusing on the most compelling evidence or reasoning. Your recommendation—Buy, Sell, or Hold—must be clear and actionable. Avoid defaulting to Hold simply because both sides have valid points; commit to a stance grounded in the debate's strongest arguments. + +Additionally, develop a detailed investment plan for the trader. This should include: + +Your Recommendation: A decisive stance supported by the most convincing arguments. +Rationale: An explanation of why these arguments lead to your conclusion. +Strategic Actions: Concrete steps for implementing the recommendation. +Take into account your past mistakes on similar situations. Use these insights to refine your decision-making and ensure you are learning and improving. Present your analysis conversationally, as if speaking naturally, without special formatting. + +Here are your past reflections on mistakes: +\"{past_memory_str}\" + +Here is the debate: +Debate History: +{history}""" + response = llm.invoke(prompt) + + new_investment_debate_state = { + "judge_decision": response.content, + "history": investment_debate_state.get("history", ""), + "bear_history": investment_debate_state.get("bear_history", ""), + "bull_history": investment_debate_state.get("bull_history", ""), + "current_response": response.content, + "count": investment_debate_state["count"], + } + + return { + "investment_debate_state": new_investment_debate_state, + "investment_plan": response.content, + } + + return research_manager_node diff --git a/tradingagents/agents/managers/risk_manager.py b/tradingagents/agents/managers/risk_manager.py new file mode 100644 index 0000000..fba763d --- /dev/null +++ b/tradingagents/agents/managers/risk_manager.py @@ -0,0 +1,66 @@ +import time +import json + + +def create_risk_manager(llm, memory): + def risk_manager_node(state) -> dict: + + company_name = state["company_of_interest"] + + history = state["risk_debate_state"]["history"] + risk_debate_state = state["risk_debate_state"] + market_research_report = state["market_report"] + news_report = state["news_report"] + fundamentals_report = state["news_report"] + sentiment_report = state["sentiment_report"] + trader_plan = state["investment_plan"] + + curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}" + past_memories = memory.get_memories(curr_situation, n_matches=2) + + past_memory_str = "" + for i, rec in enumerate(past_memories, 1): + past_memory_str += rec["recommendation"] + "\n\n" + + prompt = f"""As the Risk Management Judge and Debate Facilitator, your goal is to evaluate the debate between three risk analysts—Risky, Neutral, and Safe/Conservative—and determine the best course of action for the trader. Your decision must result in a clear recommendation: Buy, Sell, or Hold. Choose Hold only if strongly justified by specific arguments, not as a fallback when all sides seem valid. Strive for clarity and decisiveness. + +Guidelines for Decision-Making: +1. **Summarize Key Arguments**: Extract the strongest points from each analyst, focusing on relevance to the context. +2. **Provide Rationale**: Support your recommendation with direct quotes and counterarguments from the debate. +3. **Refine the Trader's Plan**: Start with the trader's original plan, **{trader_plan}**, and adjust it based on the analysts' insights. +4. **Learn from Past Mistakes**: Use lessons from **{past_memory_str}** to address prior misjudgments and improve the decision you are making now to make sure you don't make a wrong BUY/SELL/HOLD call that loses money. + +Deliverables: +- A clear and actionable recommendation: Buy, Sell, or Hold. +- Detailed reasoning anchored in the debate and past reflections. + +--- + +**Analysts Debate History:** +{history} + +--- + +Focus on actionable insights and continuous improvement. Build on past lessons, critically evaluate all perspectives, and ensure each decision advances better outcomes.""" + + response = llm.invoke(prompt) + + new_risk_debate_state = { + "judge_decision": response.content, + "history": risk_debate_state["history"], + "risky_history": risk_debate_state["risky_history"], + "safe_history": risk_debate_state["safe_history"], + "neutral_history": risk_debate_state["neutral_history"], + "latest_speaker": "Judge", + "current_risky_response": risk_debate_state["current_risky_response"], + "current_safe_response": risk_debate_state["current_safe_response"], + "current_neutral_response": risk_debate_state["current_neutral_response"], + "count": risk_debate_state["count"], + } + + return { + "risk_debate_state": new_risk_debate_state, + "final_trade_decision": response.content, + } + + return risk_manager_node diff --git a/tradingagents/agents/researchers/bear_researcher.py b/tradingagents/agents/researchers/bear_researcher.py new file mode 100644 index 0000000..6634490 --- /dev/null +++ b/tradingagents/agents/researchers/bear_researcher.py @@ -0,0 +1,61 @@ +from langchain_core.messages import AIMessage +import time +import json + + +def create_bear_researcher(llm, memory): + def bear_node(state) -> dict: + investment_debate_state = state["investment_debate_state"] + history = investment_debate_state.get("history", "") + bear_history = investment_debate_state.get("bear_history", "") + + current_response = investment_debate_state.get("current_response", "") + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}" + past_memories = memory.get_memories(curr_situation, n_matches=2) + + past_memory_str = "" + for i, rec in enumerate(past_memories, 1): + past_memory_str += rec["recommendation"] + "\n\n" + + prompt = f"""You are a Bear Analyst making the case against investing in the stock. Your goal is to present a well-reasoned argument emphasizing risks, challenges, and negative indicators. Leverage the provided research and data to highlight potential downsides and counter bullish arguments effectively. + +Key points to focus on: + +- Risks and Challenges: Highlight factors like market saturation, financial instability, or macroeconomic threats that could hinder the stock's performance. +- Competitive Weaknesses: Emphasize vulnerabilities such as weaker market positioning, declining innovation, or threats from competitors. +- Negative Indicators: Use evidence from financial data, market trends, or recent adverse news to support your position. +- Bull Counterpoints: Critically analyze the bull argument with specific data and sound reasoning, exposing weaknesses or over-optimistic assumptions. +- Engagement: Present your argument in a conversational style, directly engaging with the bull analyst's points and debating effectively rather than simply listing facts. + +Resources available: + +Market research report: {market_research_report} +Social media sentiment report: {sentiment_report} +Latest world affairs news: {news_report} +Company fundamentals report: {fundamentals_report} +Conversation history of the debate: {history} +Last bull argument: {current_response} +Reflections from similar situations and lessons learned: {past_memory_str} +Use this information to deliver a compelling bear argument, refute the bull's claims, and engage in a dynamic debate that demonstrates the risks and weaknesses of investing in the stock. You must also address reflections and learn from lessons and mistakes you made in the past. +""" + + response = llm.invoke(prompt) + + argument = f"Bear Analyst: {response.content}" + + new_investment_debate_state = { + "history": history + "\n" + argument, + "bear_history": bear_history + "\n" + argument, + "bull_history": investment_debate_state.get("bull_history", ""), + "current_response": argument, + "count": investment_debate_state["count"] + 1, + } + + return {"investment_debate_state": new_investment_debate_state} + + return bear_node diff --git a/tradingagents/agents/researchers/bull_researcher.py b/tradingagents/agents/researchers/bull_researcher.py new file mode 100644 index 0000000..b03ef75 --- /dev/null +++ b/tradingagents/agents/researchers/bull_researcher.py @@ -0,0 +1,59 @@ +from langchain_core.messages import AIMessage +import time +import json + + +def create_bull_researcher(llm, memory): + def bull_node(state) -> dict: + investment_debate_state = state["investment_debate_state"] + history = investment_debate_state.get("history", "") + bull_history = investment_debate_state.get("bull_history", "") + + current_response = investment_debate_state.get("current_response", "") + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}" + past_memories = memory.get_memories(curr_situation, n_matches=2) + + past_memory_str = "" + for i, rec in enumerate(past_memories, 1): + past_memory_str += rec["recommendation"] + "\n\n" + + prompt = f"""You are a Bull Analyst advocating for investing in the stock. Your task is to build a strong, evidence-based case emphasizing growth potential, competitive advantages, and positive market indicators. Leverage the provided research and data to address concerns and counter bearish arguments effectively. + +Key points to focus on: +- Growth Potential: Highlight the company's market opportunities, revenue projections, and scalability. +- Competitive Advantages: Emphasize factors like unique products, strong branding, or dominant market positioning. +- Positive Indicators: Use financial health, industry trends, and recent positive news as evidence. +- Bear Counterpoints: Critically analyze the bear argument with specific data and sound reasoning, addressing concerns thoroughly and showing why the bull perspective holds stronger merit. +- Engagement: Present your argument in a conversational style, engaging directly with the bear analyst's points and debating effectively rather than just listing data. + +Resources available: +Market research report: {market_research_report} +Social media sentiment report: {sentiment_report} +Latest world affairs news: {news_report} +Company fundamentals report: {fundamentals_report} +Conversation history of the debate: {history} +Last bear argument: {current_response} +Reflections from similar situations and lessons learned: {past_memory_str} +Use this information to deliver a compelling bull argument, refute the bear's concerns, and engage in a dynamic debate that demonstrates the strengths of the bull position. You must also address reflections and learn from lessons and mistakes you made in the past. +""" + + response = llm.invoke(prompt) + + argument = f"Bull Analyst: {response.content}" + + new_investment_debate_state = { + "history": history + "\n" + argument, + "bull_history": bull_history + "\n" + argument, + "bear_history": investment_debate_state.get("bear_history", ""), + "current_response": argument, + "count": investment_debate_state["count"] + 1, + } + + return {"investment_debate_state": new_investment_debate_state} + + return bull_node diff --git a/tradingagents/agents/risk_mgmt/aggresive_debator.py b/tradingagents/agents/risk_mgmt/aggresive_debator.py new file mode 100644 index 0000000..7e2b493 --- /dev/null +++ b/tradingagents/agents/risk_mgmt/aggresive_debator.py @@ -0,0 +1,55 @@ +import time +import json + + +def create_risky_debator(llm): + def risky_node(state) -> dict: + risk_debate_state = state["risk_debate_state"] + history = risk_debate_state.get("history", "") + risky_history = risk_debate_state.get("risky_history", "") + + current_safe_response = risk_debate_state.get("current_safe_response", "") + current_neutral_response = risk_debate_state.get("current_neutral_response", "") + + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + trader_decision = state["trader_investment_plan"] + + prompt = f"""As the Risky Risk Analyst, your role is to actively champion high-reward, high-risk opportunities, emphasizing bold strategies and competitive advantages. When evaluating the trader's decision or plan, focus intently on the potential upside, growth potential, and innovative benefits—even when these come with elevated risk. Use the provided market data and sentiment analysis to strengthen your arguments and challenge the opposing views. Specifically, respond directly to each point made by the conservative and neutral analysts, countering with data-driven rebuttals and persuasive reasoning. Highlight where their caution might miss critical opportunities or where their assumptions may be overly conservative. Here is the trader's decision: + +{trader_decision} + +Your task is to create a compelling case for the trader's decision by questioning and critiquing the conservative and neutral stances to demonstrate why your high-reward perspective offers the best path forward. Incorporate insights from the following sources into your arguments: + +Market Research Report: {market_research_report} +Social Media Sentiment Report: {sentiment_report} +Latest World Affairs Report: {news_report} +Company Fundamentals Report: {fundamentals_report} +Here is the current conversation history: {history} Here are the last arguments from the conservative analyst: {current_safe_response} Here are the last arguments from the neutral analyst: {current_neutral_response}. If there are no responses from the other viewpoints, do not halluncinate and just present your point. + +Engage actively by addressing any specific concerns raised, refuting the weaknesses in their logic, and asserting the benefits of risk-taking to outpace market norms. Maintain a focus on debating and persuading, not just presenting data. Challenge each counterpoint to underscore why a high-risk approach is optimal. Output conversationally as if you are speaking without any special formatting.""" + + response = llm.invoke(prompt) + + argument = f"Risky Analyst: {response.content}" + + new_risk_debate_state = { + "history": history + "\n" + argument, + "risky_history": risky_history + "\n" + argument, + "safe_history": risk_debate_state.get("safe_history", ""), + "neutral_history": risk_debate_state.get("neutral_history", ""), + "latest_speaker": "Risky", + "current_risky_response": argument, + "current_safe_response": risk_debate_state.get("current_safe_response", ""), + "current_neutral_response": risk_debate_state.get( + "current_neutral_response", "" + ), + "count": risk_debate_state["count"] + 1, + } + + return {"risk_debate_state": new_risk_debate_state} + + return risky_node diff --git a/tradingagents/agents/risk_mgmt/conservative_debator.py b/tradingagents/agents/risk_mgmt/conservative_debator.py new file mode 100644 index 0000000..c56e16a --- /dev/null +++ b/tradingagents/agents/risk_mgmt/conservative_debator.py @@ -0,0 +1,58 @@ +from langchain_core.messages import AIMessage +import time +import json + + +def create_safe_debator(llm): + def safe_node(state) -> dict: + risk_debate_state = state["risk_debate_state"] + history = risk_debate_state.get("history", "") + safe_history = risk_debate_state.get("safe_history", "") + + current_risky_response = risk_debate_state.get("current_risky_response", "") + current_neutral_response = risk_debate_state.get("current_neutral_response", "") + + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + trader_decision = state["trader_investment_plan"] + + prompt = f"""As the Safe/Conservative Risk Analyst, your primary objective is to protect assets, minimize volatility, and ensure steady, reliable growth. You prioritize stability, security, and risk mitigation, carefully assessing potential losses, economic downturns, and market volatility. When evaluating the trader's decision or plan, critically examine high-risk elements, pointing out where the decision may expose the firm to undue risk and where more cautious alternatives could secure long-term gains. Here is the trader's decision: + +{trader_decision} + +Your task is to actively counter the arguments of the Risky and Neutral Analysts, highlighting where their views may overlook potential threats or fail to prioritize sustainability. Respond directly to their points, drawing from the following data sources to build a convincing case for a low-risk approach adjustment to the trader's decision: + +Market Research Report: {market_research_report} +Social Media Sentiment Report: {sentiment_report} +Latest World Affairs Report: {news_report} +Company Fundamentals Report: {fundamentals_report} +Here is the current conversation history: {history} Here is the last response from the risky analyst: {current_risky_response} Here is the last response from the neutral analyst: {current_neutral_response}. If there are no responses from the other viewpoints, do not halluncinate and just present your point. + +Engage by questioning their optimism and emphasizing the potential downsides they may have overlooked. Address each of their counterpoints to showcase why a conservative stance is ultimately the safest path for the firm's assets. Focus on debating and critiquing their arguments to demonstrate the strength of a low-risk strategy over their approaches. Output conversationally as if you are speaking without any special formatting.""" + + response = llm.invoke(prompt) + + argument = f"Safe Analyst: {response.content}" + + new_risk_debate_state = { + "history": history + "\n" + argument, + "risky_history": risk_debate_state.get("risky_history", ""), + "safe_history": safe_history + "\n" + argument, + "neutral_history": risk_debate_state.get("neutral_history", ""), + "latest_speaker": "Safe", + "current_risky_response": risk_debate_state.get( + "current_risky_response", "" + ), + "current_safe_response": argument, + "current_neutral_response": risk_debate_state.get( + "current_neutral_response", "" + ), + "count": risk_debate_state["count"] + 1, + } + + return {"risk_debate_state": new_risk_debate_state} + + return safe_node diff --git a/tradingagents/agents/risk_mgmt/neutral_debator.py b/tradingagents/agents/risk_mgmt/neutral_debator.py new file mode 100644 index 0000000..a6d2ef5 --- /dev/null +++ b/tradingagents/agents/risk_mgmt/neutral_debator.py @@ -0,0 +1,55 @@ +import time +import json + + +def create_neutral_debator(llm): + def neutral_node(state) -> dict: + risk_debate_state = state["risk_debate_state"] + history = risk_debate_state.get("history", "") + neutral_history = risk_debate_state.get("neutral_history", "") + + current_risky_response = risk_debate_state.get("current_risky_response", "") + current_safe_response = risk_debate_state.get("current_safe_response", "") + + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + trader_decision = state["trader_investment_plan"] + + prompt = f"""As the Neutral Risk Analyst, your role is to provide a balanced perspective, weighing both the potential benefits and risks of the trader's decision or plan. You prioritize a well-rounded approach, evaluating the upsides and downsides while factoring in broader market trends, potential economic shifts, and diversification strategies.Here is the trader's decision: + +{trader_decision} + +Your task is to challenge both the Risky and Safe Analysts, pointing out where each perspective may be overly optimistic or overly cautious. Use insights from the following data sources to support a moderate, sustainable strategy to adjust the trader's decision: + +Market Research Report: {market_research_report} +Social Media Sentiment Report: {sentiment_report} +Latest World Affairs Report: {news_report} +Company Fundamentals Report: {fundamentals_report} +Here is the current conversation history: {history} Here is the last response from the risky analyst: {current_risky_response} Here is the last response from the safe analyst: {current_safe_response}. If there are no responses from the other viewpoints, do not halluncinate and just present your point. + +Engage actively by analyzing both sides critically, addressing weaknesses in the risky and conservative arguments to advocate for a more balanced approach. Challenge each of their points to illustrate why a moderate risk strategy might offer the best of both worlds, providing growth potential while safeguarding against extreme volatility. Focus on debating rather than simply presenting data, aiming to show that a balanced view can lead to the most reliable outcomes. Output conversationally as if you are speaking without any special formatting.""" + + response = llm.invoke(prompt) + + argument = f"Neutral Analyst: {response.content}" + + new_risk_debate_state = { + "history": history + "\n" + argument, + "risky_history": risk_debate_state.get("risky_history", ""), + "safe_history": risk_debate_state.get("safe_history", ""), + "neutral_history": neutral_history + "\n" + argument, + "latest_speaker": "Neutral", + "current_risky_response": risk_debate_state.get( + "current_risky_response", "" + ), + "current_safe_response": risk_debate_state.get("current_safe_response", ""), + "current_neutral_response": argument, + "count": risk_debate_state["count"] + 1, + } + + return {"risk_debate_state": new_risk_debate_state} + + return neutral_node diff --git a/tradingagents/agents/trader/trader.py b/tradingagents/agents/trader/trader.py new file mode 100644 index 0000000..282a841 --- /dev/null +++ b/tradingagents/agents/trader/trader.py @@ -0,0 +1,43 @@ +import functools +import time +import json + + +def create_trader(llm, memory): + def trader_node(state, name): + company_name = state["company_of_interest"] + investment_plan = state["investment_plan"] + market_research_report = state["market_report"] + sentiment_report = state["sentiment_report"] + news_report = state["news_report"] + fundamentals_report = state["fundamentals_report"] + + curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}" + past_memories = memory.get_memories(curr_situation, n_matches=2) + + past_memory_str = "" + for i, rec in enumerate(past_memories, 1): + past_memory_str += rec["recommendation"] + "\n\n" + + context = { + "role": "user", + "content": f"Based on a comprehensive analysis by a team of analysts, here is an investment plan tailored for {company_name}. This plan incorporates insights from current technical market trends, macroeconomic indicators, and social media sentiment. Use this plan as a foundation for evaluating your next trading decision.\n\nProposed Investment Plan: {investment_plan}\n\nLeverage these insights to make an informed and strategic decision.", + } + + messages = [ + { + "role": "system", + "content": f"""You are a trading agent analyzing market data to make investment decisions. Based on your analysis, provide a specific recommendation to buy, sell, or hold. End with a firm decision and always conclude your response with 'FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL**' to confirm your recommendation. Do not forget to utilize lessons from past decisions to learn from your mistakes. Here is some reflections from similar situatiosn you traded in and the lessons learned: {past_memory_str}""", + }, + context, + ] + + result = llm.invoke(messages) + + return { + "messages": [result], + "trader_investment_plan": result.content, + "sender": name, + } + + return functools.partial(trader_node, name="Trader") diff --git a/tradingagents/agents/utils/agent_states.py b/tradingagents/agents/utils/agent_states.py new file mode 100644 index 0000000..3a859ea --- /dev/null +++ b/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"] diff --git a/tradingagents/agents/utils/agent_utils.py b/tradingagents/agents/utils/agent_utils.py new file mode 100644 index 0000000..6e6c975 --- /dev/null +++ b/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 diff --git a/tradingagents/agents/utils/memory.py b/tradingagents/agents/utils/memory.py new file mode 100644 index 0000000..a1934bd --- /dev/null +++ b/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)}") diff --git a/tradingagents/dataflows/__init__.py b/tradingagents/dataflows/__init__.py new file mode 100644 index 0000000..b0c04d1 --- /dev/null +++ b/tradingagents/dataflows/__init__.py @@ -0,0 +1,46 @@ +from .finnhub_utils import get_data_in_range +from .googlenews_utils import getNewsData +from .yfin_utils import YFinanceUtils +from .reddit_utils import fetch_top_from_category +from .stockstats_utils import StockstatsUtils +from .yfin_utils import YFinanceUtils + +from .interface import ( + # News and sentiment functions + get_finnhub_news, + get_finnhub_company_insider_sentiment, + get_finnhub_company_insider_transactions, + get_google_news, + get_reddit_global_news, + get_reddit_company_news, + # Financial statements functions + get_simfin_balance_sheet, + get_simfin_cashflow, + get_simfin_income_statements, + # Technical analysis functions + get_stock_stats_indicators_window, + get_stockstats_indicator, + # Market data functions + get_YFin_data_window, + get_YFin_data, +) + +__all__ = [ + # News and sentiment functions + "get_finnhub_news", + "get_finnhub_company_insider_sentiment", + "get_finnhub_company_insider_transactions", + "get_google_news", + "get_reddit_global_news", + "get_reddit_company_news", + # Financial statements functions + "get_simfin_balance_sheet", + "get_simfin_cashflow", + "get_simfin_income_statements", + # Technical analysis functions + "get_stock_stats_indicators_window", + "get_stockstats_indicator", + # Market data functions + "get_YFin_data_window", + "get_YFin_data", +] diff --git a/tradingagents/dataflows/config.py b/tradingagents/dataflows/config.py new file mode 100644 index 0000000..b8a8f8a --- /dev/null +++ b/tradingagents/dataflows/config.py @@ -0,0 +1,34 @@ +import tradingagents.default_config as default_config +from typing import Dict, Optional + +# Use default config but allow it to be overridden +_config: Optional[Dict] = None +DATA_DIR: Optional[str] = None + + +def initialize_config(): + """Initialize the configuration with default values.""" + global _config, DATA_DIR + if _config is None: + _config = default_config.DEFAULT_CONFIG.copy() + DATA_DIR = _config["data_dir"] + + +def set_config(config: Dict): + """Update the configuration with custom values.""" + global _config, DATA_DIR + if _config is None: + _config = default_config.DEFAULT_CONFIG.copy() + _config.update(config) + DATA_DIR = _config["data_dir"] + + +def get_config() -> Dict: + """Get the current configuration.""" + if _config is None: + initialize_config() + return _config.copy() + + +# Initialize with default config +initialize_config() diff --git a/tradingagents/dataflows/finnhub_utils.py b/tradingagents/dataflows/finnhub_utils.py new file mode 100644 index 0000000..e7c7103 --- /dev/null +++ b/tradingagents/dataflows/finnhub_utils.py @@ -0,0 +1,36 @@ +import json +import os + + +def get_data_in_range(ticker, start_date, end_date, data_type, data_dir, period=None): + """ + Gets finnhub data saved and processed on disk. + Args: + start_date (str): Start date in YYYY-MM-DD format. + end_date (str): End date in YYYY-MM-DD format. + data_type (str): Type of data from finnhub to fetch. Can be insider_trans, SEC_filings, news_data, insider_senti, or fin_as_reported. + data_dir (str): Directory where the data is saved. + period (str): Default to none, if there is a period specified, should be annual or quarterly. + """ + + if period: + data_path = os.path.join( + data_dir, + "finnhub_data", + data_type, + f"{ticker}_{period}_data_formatted.json", + ) + else: + data_path = os.path.join( + data_dir, "finnhub_data", data_type, f"{ticker}_data_formatted.json" + ) + + data = open(data_path, "r") + data = json.load(data) + + # filter keys (date, str in format YYYY-MM-DD) by the date range (str, str in format YYYY-MM-DD) + filtered_data = {} + for key, value in data.items(): + if start_date <= key <= end_date and len(value) > 0: + filtered_data[key] = value + return filtered_data diff --git a/tradingagents/dataflows/googlenews_utils.py b/tradingagents/dataflows/googlenews_utils.py new file mode 100644 index 0000000..bdc6124 --- /dev/null +++ b/tradingagents/dataflows/googlenews_utils.py @@ -0,0 +1,108 @@ +import json +import requests +from bs4 import BeautifulSoup +from datetime import datetime +import time +import random +from tenacity import ( + retry, + stop_after_attempt, + wait_exponential, + retry_if_exception_type, + retry_if_result, +) + + +def is_rate_limited(response): + """Check if the response indicates rate limiting (status code 429)""" + return response.status_code == 429 + + +@retry( + retry=(retry_if_result(is_rate_limited)), + wait=wait_exponential(multiplier=1, min=4, max=60), + stop=stop_after_attempt(5), +) +def make_request(url, headers): + """Make a request with retry logic for rate limiting""" + # Random delay before each request to avoid detection + time.sleep(random.uniform(2, 6)) + response = requests.get(url, headers=headers) + return response + + +def getNewsData(query, start_date, end_date): + """ + Scrape Google News search results for a given query and date range. + query: str - search query + start_date: str - start date in the format yyyy-mm-dd or mm/dd/yyyy + end_date: str - end date in the format yyyy-mm-dd or mm/dd/yyyy + """ + if "-" in start_date: + start_date = datetime.strptime(start_date, "%Y-%m-%d") + start_date = start_date.strftime("%m/%d/%Y") + if "-" in end_date: + end_date = datetime.strptime(end_date, "%Y-%m-%d") + end_date = end_date.strftime("%m/%d/%Y") + + headers = { + "User-Agent": ( + "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " + "AppleWebKit/537.36 (KHTML, like Gecko) " + "Chrome/101.0.4951.54 Safari/537.36" + ) + } + + news_results = [] + page = 0 + while True: + offset = page * 10 + url = ( + f"https://www.google.com/search?q={query}" + f"&tbs=cdr:1,cd_min:{start_date},cd_max:{end_date}" + f"&tbm=nws&start={offset}" + ) + + try: + response = make_request(url, headers) + soup = BeautifulSoup(response.content, "html.parser") + results_on_page = soup.select("div.SoaBEf") + + if not results_on_page: + break # No more results found + + for el in results_on_page: + try: + link = el.find("a")["href"] + title = el.select_one("div.MBeuO").get_text() + snippet = el.select_one(".GI74Re").get_text() + date = el.select_one(".LfVVr").get_text() + source = el.select_one(".NUnG9d span").get_text() + news_results.append( + { + "link": link, + "title": title, + "snippet": snippet, + "date": date, + "source": source, + } + ) + except Exception as e: + print(f"Error processing result: {e}") + # If one of the fields is not found, skip this result + continue + + # Update the progress bar with the current count of results scraped + + # Check for the "Next" link (pagination) + next_link = soup.find("a", id="pnnext") + if not next_link: + break + + page += 1 + + except Exception as e: + print(f"Failed after multiple retries: {e}") + break + + return news_results diff --git a/tradingagents/dataflows/interface.py b/tradingagents/dataflows/interface.py new file mode 100644 index 0000000..d31d84e --- /dev/null +++ b/tradingagents/dataflows/interface.py @@ -0,0 +1,804 @@ +from typing import Annotated, Dict +from .reddit_utils import fetch_top_from_category +from .yfin_utils import * +from .stockstats_utils import * +from .googlenews_utils import * +from .finnhub_utils import get_data_in_range +from dateutil.relativedelta import relativedelta +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime +import json +import os +import pandas as pd +from tqdm import tqdm +import yfinance as yf +from openai import OpenAI +from .config import get_config, set_config, DATA_DIR + + +def get_finnhub_news( + ticker: Annotated[ + str, + "Search query of a company's, e.g. 'AAPL, TSM, etc.", + ], + curr_date: Annotated[str, "Current date in yyyy-mm-dd format"], + look_back_days: Annotated[int, "how many days to look back"], +): + """ + Retrieve news about a company within a time frame + + Args + ticker (str): ticker for the company you are interested in + start_date (str): Start date in yyyy-mm-dd format + end_date (str): End date in yyyy-mm-dd format + Returns + str: dataframe containing the news of the company in the time frame + + """ + + start_date = datetime.strptime(curr_date, "%Y-%m-%d") + before = start_date - relativedelta(days=look_back_days) + before = before.strftime("%Y-%m-%d") + + result = get_data_in_range(ticker, before, curr_date, "news_data", DATA_DIR) + + if len(result) == 0: + return "" + + combined_result = "" + for day, data in result.items(): + if len(data) == 0: + continue + for entry in data: + current_news = ( + "### " + entry["headline"] + f" ({day})" + "\n" + entry["summary"] + ) + combined_result += current_news + "\n\n" + + return f"## {ticker} News, from {before} to {curr_date}:\n" + str(combined_result) + + +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", + ], + look_back_days: Annotated[int, "number of days to look back"], +): + """ + Retrieve insider sentiment about a company (retrieved from public SEC information) for the past 15 days + Args: + ticker (str): ticker symbol of the company + curr_date (str): current date you are trading on, yyyy-mm-dd + Returns: + str: a report of the sentiment in the past 15 days starting at curr_date + """ + + date_obj = datetime.strptime(curr_date, "%Y-%m-%d") + before = date_obj - relativedelta(days=look_back_days) + before = before.strftime("%Y-%m-%d") + + data = get_data_in_range(ticker, before, curr_date, "insider_senti", DATA_DIR) + + if len(data) == 0: + return "" + + result_str = "" + seen_dicts = [] + for date, senti_list in data.items(): + for entry in senti_list: + if entry not in seen_dicts: + result_str += f"### {entry['year']}-{entry['month']}:\nChange: {entry['change']}\nMonthly Share Purchase Ratio: {entry['mspr']}\n\n" + seen_dicts.append(entry) + + return ( + f"## {ticker} Insider Sentiment Data for {before} to {curr_date}:\n" + + result_str + + "The change field refers to the net buying/selling from all insiders' transactions. The mspr field refers to monthly share purchase ratio." + ) + + +def get_finnhub_company_insider_transactions( + ticker: Annotated[str, "ticker symbol"], + curr_date: Annotated[ + str, + "current date you are trading at, yyyy-mm-dd", + ], + look_back_days: Annotated[int, "how many days to look back"], +): + """ + Retrieve insider transcaction information about a company (retrieved from public SEC information) for the past 15 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 transaction/trading informtaion in the past 15 days + """ + + date_obj = datetime.strptime(curr_date, "%Y-%m-%d") + before = date_obj - relativedelta(days=look_back_days) + before = before.strftime("%Y-%m-%d") + + data = get_data_in_range(ticker, before, curr_date, "insider_trans", DATA_DIR) + + if len(data) == 0: + return "" + + result_str = "" + + seen_dicts = [] + for date, senti_list in data.items(): + for entry in senti_list: + if entry not in seen_dicts: + result_str += f"### Filing Date: {entry['filingDate']}, {entry['name']}:\nChange:{entry['change']}\nShares: {entry['share']}\nTransaction Price: {entry['transactionPrice']}\nTransaction Code: {entry['transactionCode']}\n\n" + seen_dicts.append(entry) + + return ( + f"## {ticker} insider transactions from {before} to {curr_date}:\n" + + result_str + + "The change field reflects the variation in share count—here a negative number indicates a reduction in holdings—while share specifies the total number of shares involved. The transactionPrice denotes the per-share price at which the trade was executed, and transactionDate marks when the transaction occurred. The name field identifies the insider making the trade, and transactionCode (e.g., S for sale) clarifies the nature of the transaction. FilingDate records when the transaction was officially reported, and the unique id links to the specific SEC filing, as indicated by the source. Additionally, the symbol ties the transaction to a particular company, isDerivative flags whether the trade involves derivative securities, and currency notes the currency context of the transaction." + ) + + +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"], +): + data_path = os.path.join( + DATA_DIR, + "fundamental_data", + "simfin_data_all", + "balance_sheet", + "companies", + "us", + f"us-balance-{freq}.csv", + ) + df = pd.read_csv(data_path, sep=";") + + # Convert date strings to datetime objects and remove any time components + df["Report Date"] = pd.to_datetime(df["Report Date"], utc=True).dt.normalize() + df["Publish Date"] = pd.to_datetime(df["Publish Date"], utc=True).dt.normalize() + + # Convert the current date to datetime and normalize + curr_date_dt = pd.to_datetime(curr_date, utc=True).normalize() + + # Filter the DataFrame for the given ticker and for reports that were published on or before the current date + filtered_df = df[(df["Ticker"] == ticker) & (df["Publish Date"] <= curr_date_dt)] + + # Check if there are any available reports; if not, return a notification + if filtered_df.empty: + print("No balance sheet available before the given current date.") + return "" + + # Get the most recent balance sheet by selecting the row with the latest Publish Date + latest_balance_sheet = filtered_df.loc[filtered_df["Publish Date"].idxmax()] + + # drop the SimFinID column + latest_balance_sheet = latest_balance_sheet.drop("SimFinId") + + return ( + f"## {freq} balance sheet for {ticker} released on {str(latest_balance_sheet['Publish Date'])[0:10]}: \n" + + str(latest_balance_sheet) + + "\n\nThis includes metadata like reporting dates and currency, share details, and a breakdown of assets, liabilities, and equity. Assets are grouped as current (liquid items like cash and receivables) and noncurrent (long-term investments and property). Liabilities are split between short-term obligations and long-term debts, while equity reflects shareholder funds such as paid-in capital and retained earnings. Together, these components ensure that total assets equal the sum of liabilities and equity." + ) + + +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"], +): + data_path = os.path.join( + DATA_DIR, + "fundamental_data", + "simfin_data_all", + "cash_flow", + "companies", + "us", + f"us-cashflow-{freq}.csv", + ) + df = pd.read_csv(data_path, sep=";") + + # Convert date strings to datetime objects and remove any time components + df["Report Date"] = pd.to_datetime(df["Report Date"], utc=True).dt.normalize() + df["Publish Date"] = pd.to_datetime(df["Publish Date"], utc=True).dt.normalize() + + # Convert the current date to datetime and normalize + curr_date_dt = pd.to_datetime(curr_date, utc=True).normalize() + + # Filter the DataFrame for the given ticker and for reports that were published on or before the current date + filtered_df = df[(df["Ticker"] == ticker) & (df["Publish Date"] <= curr_date_dt)] + + # Check if there are any available reports; if not, return a notification + if filtered_df.empty: + print("No cash flow statement available before the given current date.") + return "" + + # Get the most recent cash flow statement by selecting the row with the latest Publish Date + latest_cash_flow = filtered_df.loc[filtered_df["Publish Date"].idxmax()] + + # drop the SimFinID column + latest_cash_flow = latest_cash_flow.drop("SimFinId") + + return ( + f"## {freq} cash flow statement for {ticker} released on {str(latest_cash_flow['Publish Date'])[0:10]}: \n" + + str(latest_cash_flow) + + "\n\nThis includes metadata like reporting dates and currency, share details, and a breakdown of cash movements. Operating activities show cash generated from core business operations, including net income adjustments for non-cash items and working capital changes. Investing activities cover asset acquisitions/disposals and investments. Financing activities include debt transactions, equity issuances/repurchases, and dividend payments. The net change in cash represents the overall increase or decrease in the company's cash position during the reporting period." + ) + + +def get_simfin_income_statements( + 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"], +): + data_path = os.path.join( + DATA_DIR, + "fundamental_data", + "simfin_data_all", + "income_statements", + "companies", + "us", + f"us-income-{freq}.csv", + ) + df = pd.read_csv(data_path, sep=";") + + # Convert date strings to datetime objects and remove any time components + df["Report Date"] = pd.to_datetime(df["Report Date"], utc=True).dt.normalize() + df["Publish Date"] = pd.to_datetime(df["Publish Date"], utc=True).dt.normalize() + + # Convert the current date to datetime and normalize + curr_date_dt = pd.to_datetime(curr_date, utc=True).normalize() + + # Filter the DataFrame for the given ticker and for reports that were published on or before the current date + filtered_df = df[(df["Ticker"] == ticker) & (df["Publish Date"] <= curr_date_dt)] + + # Check if there are any available reports; if not, return a notification + if filtered_df.empty: + print("No income statement available before the given current date.") + return "" + + # Get the most recent income statement by selecting the row with the latest Publish Date + latest_income = filtered_df.loc[filtered_df["Publish Date"].idxmax()] + + # drop the SimFinID column + latest_income = latest_income.drop("SimFinId") + + return ( + f"## {freq} income statement for {ticker} released on {str(latest_income['Publish Date'])[0:10]}: \n" + + str(latest_income) + + "\n\nThis includes metadata like reporting dates and currency, share details, and a comprehensive breakdown of the company's financial performance. Starting with Revenue, it shows Cost of Revenue and resulting Gross Profit. Operating Expenses are detailed, including SG&A, R&D, and Depreciation. The statement then shows Operating Income, followed by non-operating items and Interest Expense, leading to Pretax Income. After accounting for Income Tax and any Extraordinary items, it concludes with Net Income, representing the company's bottom-line profit or loss for the period." + ) + + +def get_google_news( + query: Annotated[str, "Query to search with"], + curr_date: Annotated[str, "Curr date in yyyy-mm-dd format"], + look_back_days: Annotated[int, "how many days to look back"], +) -> str: + query = query.replace(" ", "+") + + start_date = datetime.strptime(curr_date, "%Y-%m-%d") + before = start_date - relativedelta(days=look_back_days) + before = before.strftime("%Y-%m-%d") + + news_results = getNewsData(query, before, curr_date) + + news_str = "" + + for news in news_results: + news_str += ( + f"### {news['title']} (source: {news['source']}) \n\n{news['snippet']}\n\n" + ) + + if len(news_results) == 0: + return "" + + return f"## {query} Google News, from {before} to {curr_date}:\n\n{news_str}" + + +def get_reddit_global_news( + start_date: Annotated[str, "Start date in yyyy-mm-dd format"], + look_back_days: Annotated[int, "how many days to look back"], + max_limit_per_day: Annotated[int, "Maximum number of news per day"], +) -> str: + """ + Retrieve the latest top reddit news + Args: + start_date: Start date in yyyy-mm-dd format + end_date: End date in yyyy-mm-dd format + Returns: + str: A formatted dataframe containing the latest news articles posts on reddit and meta information in these columns: "created_utc", "id", "title", "selftext", "score", "num_comments", "url" + """ + + start_date = datetime.strptime(start_date, "%Y-%m-%d") + before = start_date - relativedelta(days=look_back_days) + before = before.strftime("%Y-%m-%d") + + posts = [] + # iterate from start_date to end_date + curr_date = datetime.strptime(before, "%Y-%m-%d") + + total_iterations = (start_date - curr_date).days + 1 + pbar = tqdm(desc=f"Getting Global News on {start_date}", total=total_iterations) + + while curr_date <= start_date: + curr_date_str = curr_date.strftime("%Y-%m-%d") + fetch_result = fetch_top_from_category( + "global_news", + curr_date_str, + max_limit_per_day, + data_path=os.path.join(DATA_DIR, "reddit_data"), + ) + posts.extend(fetch_result) + curr_date += relativedelta(days=1) + pbar.update(1) + + pbar.close() + + if len(posts) == 0: + return "" + + news_str = "" + for post in posts: + if post["content"] == "": + news_str += f"### {post['title']}\n\n" + else: + news_str += f"### {post['title']}\n\n{post['content']}\n\n" + + return f"## Global News Reddit, from {before} to {curr_date}:\n{news_str}" + + +def get_reddit_company_news( + ticker: Annotated[str, "ticker symbol of the company"], + start_date: Annotated[str, "Start date in yyyy-mm-dd format"], + look_back_days: Annotated[int, "how many days to look back"], + max_limit_per_day: Annotated[int, "Maximum number of news per day"], +) -> str: + """ + Retrieve the latest top reddit news + Args: + ticker: ticker symbol of the company + start_date: Start date in yyyy-mm-dd format + end_date: End date in yyyy-mm-dd format + Returns: + str: A formatted dataframe containing the latest news articles posts on reddit and meta information in these columns: "created_utc", "id", "title", "selftext", "score", "num_comments", "url" + """ + + start_date = datetime.strptime(start_date, "%Y-%m-%d") + before = start_date - relativedelta(days=look_back_days) + before = before.strftime("%Y-%m-%d") + + posts = [] + # iterate from start_date to end_date + curr_date = datetime.strptime(before, "%Y-%m-%d") + + total_iterations = (start_date - curr_date).days + 1 + pbar = tqdm( + desc=f"Getting Company News for {ticker} on {start_date}", + total=total_iterations, + ) + + while curr_date <= start_date: + curr_date_str = curr_date.strftime("%Y-%m-%d") + fetch_result = fetch_top_from_category( + "company_news", + curr_date_str, + max_limit_per_day, + ticker, + data_path=os.path.join(DATA_DIR, "reddit_data"), + ) + posts.extend(fetch_result) + curr_date += relativedelta(days=1) + + pbar.update(1) + + pbar.close() + + if len(posts) == 0: + return "" + + news_str = "" + for post in posts: + if post["content"] == "": + news_str += f"### {post['title']}\n\n" + else: + news_str += f"### {post['title']}\n\n{post['content']}\n\n" + + return f"##{ticker} News Reddit, from {before} to {curr_date}:\n\n{news_str}" + + +def get_stock_stats_indicators_window( + 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"], + online: Annotated[bool, "to fetch data online or offline"], +) -> str: + + best_ind_params = { + # Moving Averages + "close_50_sma": ( + "50 SMA: A medium-term trend indicator. " + "Usage: Identify trend direction and serve as dynamic support/resistance. " + "Tips: It lags price; combine with faster indicators for timely signals." + ), + "close_200_sma": ( + "200 SMA: A long-term trend benchmark. " + "Usage: Confirm overall market trend and identify golden/death cross setups. " + "Tips: It reacts slowly; best for strategic trend confirmation rather than frequent trading entries." + ), + "close_10_ema": ( + "10 EMA: A responsive short-term average. " + "Usage: Capture quick shifts in momentum and potential entry points. " + "Tips: Prone to noise in choppy markets; use alongside longer averages for filtering false signals." + ), + # MACD Related + "macd": ( + "MACD: Computes momentum via differences of EMAs. " + "Usage: Look for crossovers and divergence as signals of trend changes. " + "Tips: Confirm with other indicators in low-volatility or sideways markets." + ), + "macds": ( + "MACD Signal: An EMA smoothing of the MACD line. " + "Usage: Use crossovers with the MACD line to trigger trades. " + "Tips: Should be part of a broader strategy to avoid false positives." + ), + "macdh": ( + "MACD Histogram: Shows the gap between the MACD line and its signal. " + "Usage: Visualize momentum strength and spot divergence early. " + "Tips: Can be volatile; complement with additional filters in fast-moving markets." + ), + # Momentum Indicators + "rsi": ( + "RSI: Measures momentum to flag overbought/oversold conditions. " + "Usage: Apply 70/30 thresholds and watch for divergence to signal reversals. " + "Tips: In strong trends, RSI may remain extreme; always cross-check with trend analysis." + ), + # Volatility Indicators + "boll": ( + "Bollinger Middle: A 20 SMA serving as the basis for Bollinger Bands. " + "Usage: Acts as a dynamic benchmark for price movement. " + "Tips: Combine with the upper and lower bands to effectively spot breakouts or reversals." + ), + "boll_ub": ( + "Bollinger Upper Band: Typically 2 standard deviations above the middle line. " + "Usage: Signals potential overbought conditions and breakout zones. " + "Tips: Confirm signals with other tools; prices may ride the band in strong trends." + ), + "boll_lb": ( + "Bollinger Lower Band: Typically 2 standard deviations below the middle line. " + "Usage: Indicates potential oversold conditions. " + "Tips: Use additional analysis to avoid false reversal signals." + ), + "atr": ( + "ATR: Averages true range to measure volatility. " + "Usage: Set stop-loss levels and adjust position sizes based on current market volatility. " + "Tips: It's a reactive measure, so use it as part of a broader risk management strategy." + ), + # Volume-Based Indicators + "vwma": ( + "VWMA: A moving average weighted by volume. " + "Usage: Confirm trends by integrating price action with volume data. " + "Tips: Watch for skewed results from volume spikes; use in combination with other volume analyses." + ), + "mfi": ( + "MFI: The Money Flow Index is a momentum indicator that uses both price and volume to measure buying and selling pressure. " + "Usage: Identify overbought (>80) or oversold (<20) conditions and confirm the strength of trends or reversals. " + "Tips: Use alongside RSI or MACD to confirm signals; divergence between price and MFI can indicate potential reversals." + ), + } + + if indicator not in best_ind_params: + raise ValueError( + f"Indicator {indicator} is not supported. Please choose from: {list(best_ind_params.keys())}" + ) + + end_date = curr_date + curr_date = datetime.strptime(curr_date, "%Y-%m-%d") + before = curr_date - relativedelta(days=look_back_days) + + if not online: + # read from YFin data + data = pd.read_csv( + os.path.join( + DATA_DIR, + f"market_data/price_data/{symbol}-YFin-data-2015-01-01-2025-03-25.csv", + ) + ) + data["Date"] = pd.to_datetime(data["Date"], utc=True) + dates_in_df = data["Date"].astype(str).str[:10] + + ind_string = "" + while curr_date >= before: + # only do the trading dates + if curr_date.strftime("%Y-%m-%d") in dates_in_df.values: + indicator_value = get_stockstats_indicator( + symbol, indicator, curr_date.strftime("%Y-%m-%d"), online + ) + + ind_string += f"{curr_date.strftime('%Y-%m-%d')}: {indicator_value}\n" + + curr_date = curr_date - relativedelta(days=1) + else: + # online gathering + ind_string = "" + while curr_date >= before: + indicator_value = get_stockstats_indicator( + symbol, indicator, curr_date.strftime("%Y-%m-%d"), online + ) + + ind_string += f"{curr_date.strftime('%Y-%m-%d')}: {indicator_value}\n" + + curr_date = curr_date - relativedelta(days=1) + + result_str = ( + f"## {indicator} values from {before.strftime('%Y-%m-%d')} to {end_date}:\n\n" + + ind_string + + "\n\n" + + best_ind_params.get(indicator, "No description available.") + ) + + return result_str + + +def get_stockstats_indicator( + 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" + ], + online: Annotated[bool, "to fetch data online or offline"], +) -> str: + + curr_date = datetime.strptime(curr_date, "%Y-%m-%d") + curr_date = curr_date.strftime("%Y-%m-%d") + + try: + indicator_value = StockstatsUtils.get_stock_stats( + symbol, + indicator, + curr_date, + os.path.join(DATA_DIR, "market_data", "price_data"), + online=online, + ) + except Exception as e: + print( + f"Error getting stockstats indicator data for indicator {indicator} on {curr_date}: {e}" + ) + return "" + + return str(indicator_value) + + +def get_YFin_data_window( + symbol: Annotated[str, "ticker symbol of the company"], + curr_date: Annotated[str, "Start date in yyyy-mm-dd format"], + look_back_days: Annotated[int, "how many days to look back"], +) -> str: + # calculate past days + date_obj = datetime.strptime(curr_date, "%Y-%m-%d") + before = date_obj - relativedelta(days=look_back_days) + start_date = before.strftime("%Y-%m-%d") + + # read in data + data = pd.read_csv( + os.path.join( + DATA_DIR, + f"market_data/price_data/{symbol}-YFin-data-2015-01-01-2025-03-25.csv", + ) + ) + + # Extract just the date part for comparison + data["DateOnly"] = data["Date"].str[:10] + + # Filter data between the start and end dates (inclusive) + filtered_data = data[ + (data["DateOnly"] >= start_date) & (data["DateOnly"] <= curr_date) + ] + + # Drop the temporary column we created + filtered_data = filtered_data.drop("DateOnly", axis=1) + + # Set pandas display options to show the full DataFrame + with pd.option_context( + "display.max_rows", None, "display.max_columns", None, "display.width", None + ): + df_string = filtered_data.to_string() + + return ( + f"## Raw Market Data for {symbol} from {start_date} to {curr_date}:\n\n" + + df_string + ) + + +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"], +): + + datetime.strptime(start_date, "%Y-%m-%d") + datetime.strptime(end_date, "%Y-%m-%d") + + # Create ticker object + ticker = yf.Ticker(symbol.upper()) + + # Fetch historical data for the specified date range + data = ticker.history(start=start_date, end=end_date) + + # Check if data is empty + if data.empty: + return ( + f"No data found for symbol '{symbol}' between {start_date} and {end_date}" + ) + + # Remove timezone info from index for cleaner output + if data.index.tz is not None: + data.index = data.index.tz_localize(None) + + # Round numerical values to 2 decimal places for cleaner display + numeric_columns = ["Open", "High", "Low", "Close", "Adj Close"] + for col in numeric_columns: + if col in data.columns: + data[col] = data[col].round(2) + + # Convert DataFrame to CSV string + csv_string = data.to_csv() + + # Add header information + header = f"# Stock data for {symbol.upper()} from {start_date} to {end_date}\n" + header += f"# Total records: {len(data)}\n" + header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n" + + return header + csv_string + + +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: + # read in data + data = pd.read_csv( + os.path.join( + DATA_DIR, + f"market_data/price_data/{symbol}-YFin-data-2015-01-01-2025-03-25.csv", + ) + ) + + if end_date > "2025-03-25": + raise Exception( + f"Get_YFin_Data: {end_date} is outside of the data range of 2015-01-01 to 2025-03-25" + ) + + # Extract just the date part for comparison + data["DateOnly"] = data["Date"].str[:10] + + # Filter data between the start and end dates (inclusive) + filtered_data = data[ + (data["DateOnly"] >= start_date) & (data["DateOnly"] <= end_date) + ] + + # Drop the temporary column we created + filtered_data = filtered_data.drop("DateOnly", axis=1) + + # remove the index from the dataframe + filtered_data = filtered_data.reset_index(drop=True) + + return filtered_data + + +def get_stock_news_openai(ticker, curr_date): + client = OpenAI() + + response = client.responses.create( + model="gpt-4.1-mini", + input=[ + { + "role": "system", + "content": [ + { + "type": "input_text", + "text": f"Can you search Social Media for {ticker} on TSLA from 7 days before {curr_date} to {curr_date}? Make sure you only get the data posted during that period.", + } + ], + } + ], + text={"format": {"type": "text"}}, + reasoning={}, + tools=[ + { + "type": "web_search_preview", + "user_location": {"type": "approximate"}, + "search_context_size": "low", + } + ], + temperature=1, + max_output_tokens=4096, + top_p=1, + store=True, + ) + + return response.output[1].content[0].text + + +def get_global_news_openai(curr_date): + client = OpenAI() + + response = client.responses.create( + model="gpt-4.1-mini", + input=[ + { + "role": "system", + "content": [ + { + "type": "input_text", + "text": f"Can you search global or macroeconomics news from 7 days before {curr_date} to {curr_date} that would be informative for trading purposes? Make sure you only get the data posted during that period.", + } + ], + } + ], + text={"format": {"type": "text"}}, + reasoning={}, + tools=[ + { + "type": "web_search_preview", + "user_location": {"type": "approximate"}, + "search_context_size": "low", + } + ], + temperature=1, + max_output_tokens=4096, + top_p=1, + store=True, + ) + + return response.output[1].content[0].text + + +def get_fundamentals_openai(ticker, curr_date): + client = OpenAI() + + response = client.responses.create( + model="gpt-4.1-mini", + input=[ + { + "role": "system", + "content": [ + { + "type": "input_text", + "text": f"Can you search Fundamental for discussions on {ticker} during of the month before {curr_date} to the month of {curr_date}. Make sure you only get the data posted during that period. List as a table, with PE/PS/Cash flow/ etc", + } + ], + } + ], + text={"format": {"type": "text"}}, + reasoning={}, + tools=[ + { + "type": "web_search_preview", + "user_location": {"type": "approximate"}, + "search_context_size": "low", + } + ], + temperature=1, + max_output_tokens=4096, + top_p=1, + store=True, + ) + + return response.output[1].content[0].text diff --git a/tradingagents/dataflows/reddit_utils.py b/tradingagents/dataflows/reddit_utils.py new file mode 100644 index 0000000..2532f0d --- /dev/null +++ b/tradingagents/dataflows/reddit_utils.py @@ -0,0 +1,135 @@ +import requests +import time +import json +from datetime import datetime, timedelta +from contextlib import contextmanager +from typing import Annotated +import os +import re + +ticker_to_company = { + "AAPL": "Apple", + "MSFT": "Microsoft", + "GOOGL": "Google", + "AMZN": "Amazon", + "TSLA": "Tesla", + "NVDA": "Nvidia", + "TSM": "Taiwan Semiconductor Manufacturing Company OR TSMC", + "JPM": "JPMorgan Chase OR JP Morgan", + "JNJ": "Johnson & Johnson OR JNJ", + "V": "Visa", + "WMT": "Walmart", + "META": "Meta OR Facebook", + "AMD": "AMD", + "INTC": "Intel", + "QCOM": "Qualcomm", + "BABA": "Alibaba", + "ADBE": "Adobe", + "NFLX": "Netflix", + "CRM": "Salesforce", + "PYPL": "PayPal", + "PLTR": "Palantir", + "MU": "Micron", + "SQ": "Block OR Square", + "ZM": "Zoom", + "CSCO": "Cisco", + "SHOP": "Shopify", + "ORCL": "Oracle", + "X": "Twitter OR X", + "SPOT": "Spotify", + "AVGO": "Broadcom", + "ASML": "ASML ", + "TWLO": "Twilio", + "SNAP": "Snap Inc.", + "TEAM": "Atlassian", + "SQSP": "Squarespace", + "UBER": "Uber", + "ROKU": "Roku", + "PINS": "Pinterest", +} + + +def fetch_top_from_category( + category: Annotated[ + str, "Category to fetch top post from. Collection of subreddits." + ], + date: Annotated[str, "Date to fetch top posts from."], + max_limit: Annotated[int, "Maximum number of posts to fetch."], + query: Annotated[str, "Optional query to search for in the subreddit."] = None, + data_path: Annotated[ + str, + "Path to the data folder. Default is 'reddit_data'.", + ] = "reddit_data", +): + base_path = data_path + + all_content = [] + + if max_limit < len(os.listdir(os.path.join(base_path, category))): + raise ValueError( + "REDDIT FETCHING ERROR: max limit is less than the number of files in the category. Will not be able to fetch any posts" + ) + + limit_per_subreddit = max_limit // len( + os.listdir(os.path.join(base_path, category)) + ) + + for data_file in os.listdir(os.path.join(base_path, category)): + # check if data_file is a .jsonl file + if not data_file.endswith(".jsonl"): + continue + + all_content_curr_subreddit = [] + + with open(os.path.join(base_path, category, data_file), "rb") as f: + for i, line in enumerate(f): + # skip empty lines + if not line.strip(): + continue + + parsed_line = json.loads(line) + + # select only lines that are from the date + post_date = datetime.utcfromtimestamp( + parsed_line["created_utc"] + ).strftime("%Y-%m-%d") + if post_date != date: + continue + + # if is company_news, check that the title or the content has the company's name (query) mentioned + if "company" in category and query: + search_terms = [] + if "OR" in ticker_to_company[query]: + search_terms = ticker_to_company[query].split(" OR ") + else: + search_terms = [ticker_to_company[query]] + + search_terms.append(query) + + found = False + for term in search_terms: + if re.search( + term, parsed_line["title"], re.IGNORECASE + ) or re.search(term, parsed_line["selftext"], re.IGNORECASE): + found = True + break + + if not found: + continue + + post = { + "title": parsed_line["title"], + "content": parsed_line["selftext"], + "url": parsed_line["url"], + "upvotes": parsed_line["ups"], + "posted_date": post_date, + } + + all_content_curr_subreddit.append(post) + + # sort all_content_curr_subreddit by upvote_ratio in descending order + all_content_curr_subreddit.sort(key=lambda x: x["upvotes"], reverse=True) + + all_content.extend(all_content_curr_subreddit[:limit_per_subreddit]) + + return all_content diff --git a/tradingagents/dataflows/stockstats_utils.py b/tradingagents/dataflows/stockstats_utils.py new file mode 100644 index 0000000..78ffb22 --- /dev/null +++ b/tradingagents/dataflows/stockstats_utils.py @@ -0,0 +1,87 @@ +import pandas as pd +import yfinance as yf +from stockstats import wrap +from typing import Annotated +import os +from .config import get_config + + +class StockstatsUtils: + @staticmethod + def get_stock_stats( + symbol: Annotated[str, "ticker symbol for the company"], + indicator: Annotated[ + str, "quantitative indicators based off of the stock data for the company" + ], + curr_date: Annotated[ + str, "curr date for retrieving stock price data, YYYY-mm-dd" + ], + data_dir: Annotated[ + str, + "directory where the stock data is stored.", + ], + online: Annotated[ + bool, + "whether to use online tools to fetch data or offline tools. If True, will use online tools.", + ] = False, + ): + df = None + data = None + + if not online: + try: + data = pd.read_csv( + os.path.join( + data_dir, + f"{symbol}-YFin-data-2015-01-01-2025-03-25.csv", + ) + ) + df = wrap(data) + except FileNotFoundError: + raise Exception("Stockstats fail: Yahoo Finance data not fetched yet!") + else: + # Get today's date as YYYY-mm-dd to add to cache + today_date = pd.Timestamp.today() + curr_date = pd.to_datetime(curr_date) + + end_date = today_date + start_date = today_date - pd.DateOffset(years=15) + start_date = start_date.strftime("%Y-%m-%d") + end_date = end_date.strftime("%Y-%m-%d") + + # Get config and ensure cache directory exists + config = get_config() + os.makedirs(config["data_cache_dir"], exist_ok=True) + + data_file = os.path.join( + config["data_cache_dir"], + f"{symbol}-YFin-data-{start_date}-{end_date}.csv", + ) + + if os.path.exists(data_file): + data = pd.read_csv(data_file) + data["Date"] = pd.to_datetime(data["Date"]) + else: + data = yf.download( + symbol, + start=start_date, + end=end_date, + multi_level_index=False, + progress=False, + auto_adjust=True, + ) + data = data.reset_index() + data.to_csv(data_file, index=False) + + df = wrap(data) + df["Date"] = df["Date"].dt.strftime("%Y-%m-%d") + curr_date = curr_date.strftime("%Y-%m-%d") + + df[indicator] # trigger stockstats to calculate the indicator + matching_rows = df[df["Date"].str.startswith(curr_date)] + + if not matching_rows.empty: + indicator_value = matching_rows[indicator].values[0] + return indicator_value + else: + return "N/A: Not a trading day (weekend or holiday)" diff --git a/tradingagents/dataflows/utils.py b/tradingagents/dataflows/utils.py new file mode 100644 index 0000000..4523de1 --- /dev/null +++ b/tradingagents/dataflows/utils.py @@ -0,0 +1,39 @@ +import os +import json +import pandas as pd +from datetime import date, timedelta, datetime +from typing import Annotated + +SavePathType = Annotated[str, "File path to save data. If None, data is not saved."] + +def save_output(data: pd.DataFrame, tag: str, save_path: SavePathType = None) -> None: + if save_path: + data.to_csv(save_path) + print(f"{tag} saved to {save_path}") + + +def get_current_date(): + return date.today().strftime("%Y-%m-%d") + + +def decorate_all_methods(decorator): + def class_decorator(cls): + for attr_name, attr_value in cls.__dict__.items(): + if callable(attr_value): + setattr(cls, attr_name, decorator(attr_value)) + return cls + + return class_decorator + + +def get_next_weekday(date): + + if not isinstance(date, datetime): + date = datetime.strptime(date, "%Y-%m-%d") + + if date.weekday() >= 5: + days_to_add = 7 - date.weekday() + next_weekday = date + timedelta(days=days_to_add) + return next_weekday + else: + return date diff --git a/tradingagents/dataflows/yfin_utils.py b/tradingagents/dataflows/yfin_utils.py new file mode 100644 index 0000000..bd7ca32 --- /dev/null +++ b/tradingagents/dataflows/yfin_utils.py @@ -0,0 +1,117 @@ +# gets data/stats + +import yfinance as yf +from typing import Annotated, Callable, Any, Optional +from pandas import DataFrame +import pandas as pd +from functools import wraps + +from .utils import save_output, SavePathType, decorate_all_methods + + +def init_ticker(func: Callable) -> Callable: + """Decorator to initialize yf.Ticker and pass it to the function.""" + + @wraps(func) + def wrapper(symbol: Annotated[str, "ticker symbol"], *args, **kwargs) -> Any: + ticker = yf.Ticker(symbol) + return func(ticker, *args, **kwargs) + + return wrapper + + +@decorate_all_methods(init_ticker) +class YFinanceUtils: + + def get_stock_data( + symbol: Annotated[str, "ticker symbol"], + start_date: Annotated[ + str, "start date for retrieving stock price data, YYYY-mm-dd" + ], + end_date: Annotated[ + str, "end date for retrieving stock price data, YYYY-mm-dd" + ], + save_path: SavePathType = None, + ) -> DataFrame: + """retrieve stock price data for designated ticker symbol""" + ticker = symbol + # add one day to the end_date so that the data range is inclusive + end_date = pd.to_datetime(end_date) + pd.DateOffset(days=1) + end_date = end_date.strftime("%Y-%m-%d") + stock_data = ticker.history(start=start_date, end=end_date) + # save_output(stock_data, f"Stock data for {ticker.ticker}", save_path) + return stock_data + + def get_stock_info( + symbol: Annotated[str, "ticker symbol"], + ) -> dict: + """Fetches and returns latest stock information.""" + ticker = symbol + stock_info = ticker.info + return stock_info + + def get_company_info( + symbol: Annotated[str, "ticker symbol"], + save_path: Optional[str] = None, + ) -> DataFrame: + """Fetches and returns company information as a DataFrame.""" + ticker = symbol + info = ticker.info + company_info = { + "Company Name": info.get("shortName", "N/A"), + "Industry": info.get("industry", "N/A"), + "Sector": info.get("sector", "N/A"), + "Country": info.get("country", "N/A"), + "Website": info.get("website", "N/A"), + } + company_info_df = DataFrame([company_info]) + if save_path: + company_info_df.to_csv(save_path) + print(f"Company info for {ticker.ticker} saved to {save_path}") + return company_info_df + + def get_stock_dividends( + symbol: Annotated[str, "ticker symbol"], + save_path: Optional[str] = None, + ) -> DataFrame: + """Fetches and returns the latest dividends data as a DataFrame.""" + ticker = symbol + dividends = ticker.dividends + if save_path: + dividends.to_csv(save_path) + print(f"Dividends for {ticker.ticker} saved to {save_path}") + return dividends + + def get_income_stmt(symbol: Annotated[str, "ticker symbol"]) -> DataFrame: + """Fetches and returns the latest income statement of the company as a DataFrame.""" + ticker = symbol + income_stmt = ticker.financials + return income_stmt + + def get_balance_sheet(symbol: Annotated[str, "ticker symbol"]) -> DataFrame: + """Fetches and returns the latest balance sheet of the company as a DataFrame.""" + ticker = symbol + balance_sheet = ticker.balance_sheet + return balance_sheet + + def get_cash_flow(symbol: Annotated[str, "ticker symbol"]) -> DataFrame: + """Fetches and returns the latest cash flow statement of the company as a DataFrame.""" + ticker = symbol + cash_flow = ticker.cashflow + return cash_flow + + def get_analyst_recommendations(symbol: Annotated[str, "ticker symbol"]) -> tuple: + """Fetches the latest analyst recommendations and returns the most common recommendation and its count.""" + ticker = symbol + recommendations = ticker.recommendations + if recommendations.empty: + return None, 0 # No recommendations available + + # Assuming 'period' column exists and needs to be excluded + row_0 = recommendations.iloc[0, 1:] # Exclude 'period' column if necessary + + # Find the maximum voting result + max_votes = row_0.max() + majority_voting_result = row_0[row_0 == max_votes].index.tolist() + + return majority_voting_result[0], max_votes diff --git a/tradingagents/default_config.py b/tradingagents/default_config.py new file mode 100644 index 0000000..5bb2548 --- /dev/null +++ b/tradingagents/default_config.py @@ -0,0 +1,19 @@ +import os + +DEFAULT_CONFIG = { + "project_dir": os.path.abspath(os.path.join(os.path.dirname(__file__), ".")), + "data_dir": "/Users/yluo/Documents/Code/ScAI/FR1-data", + "data_cache_dir": os.path.join( + os.path.abspath(os.path.join(os.path.dirname(__file__), ".")), + "dataflows/data_cache", + ), + # LLM settings + "deep_think_llm": "o4-mini", + "quick_think_llm": "gpt-4o-mini", + # Debate and discussion settings + "max_debate_rounds": 1, + "max_risk_discuss_rounds": 1, + "max_recur_limit": 100, + # Tool settings + "online_tools": True, +} diff --git a/tradingagents/graph/__init__.py b/tradingagents/graph/__init__.py new file mode 100644 index 0000000..80982c1 --- /dev/null +++ b/tradingagents/graph/__init__.py @@ -0,0 +1,17 @@ +# TradingAgents/graph/__init__.py + +from .trading_graph import TradingAgentsGraph +from .conditional_logic import ConditionalLogic +from .setup import GraphSetup +from .propagation import Propagator +from .reflection import Reflector +from .signal_processing import SignalProcessor + +__all__ = [ + "TradingAgentsGraph", + "ConditionalLogic", + "GraphSetup", + "Propagator", + "Reflector", + "SignalProcessor", +] diff --git a/tradingagents/graph/conditional_logic.py b/tradingagents/graph/conditional_logic.py new file mode 100644 index 0000000..e7c8785 --- /dev/null +++ b/tradingagents/graph/conditional_logic.py @@ -0,0 +1,67 @@ +# TradingAgents/graph/conditional_logic.py + +from tradingagents.agents.utils.agent_states import AgentState + + +class ConditionalLogic: + """Handles conditional logic for determining graph flow.""" + + def __init__(self, max_debate_rounds=1, max_risk_discuss_rounds=1): + """Initialize with configuration parameters.""" + self.max_debate_rounds = max_debate_rounds + self.max_risk_discuss_rounds = max_risk_discuss_rounds + + def should_continue_market(self, state: AgentState): + """Determine if market analysis should continue.""" + messages = state["messages"] + last_message = messages[-1] + if last_message.tool_calls: + return "tools_market" + return "Msg Clear Market" + + def should_continue_social(self, state: AgentState): + """Determine if social media analysis should continue.""" + messages = state["messages"] + last_message = messages[-1] + if last_message.tool_calls: + return "tools_social" + return "Msg Clear Social" + + def should_continue_news(self, state: AgentState): + """Determine if news analysis should continue.""" + messages = state["messages"] + last_message = messages[-1] + if last_message.tool_calls: + return "tools_news" + return "Msg Clear News" + + def should_continue_fundamentals(self, state: AgentState): + """Determine if fundamentals analysis should continue.""" + messages = state["messages"] + last_message = messages[-1] + if last_message.tool_calls: + return "tools_fundamentals" + return "Msg Clear Fundamentals" + + def should_continue_debate(self, state: AgentState) -> str: + """Determine if debate should continue.""" + + if ( + state["investment_debate_state"]["count"] >= 2 * self.max_debate_rounds + ): # 3 rounds of back-and-forth between 2 agents + return "Research Manager" + if state["investment_debate_state"]["current_response"].startswith("Bull"): + return "Bear Researcher" + return "Bull Researcher" + + def should_continue_risk_analysis(self, state: AgentState) -> str: + """Determine if risk analysis should continue.""" + if ( + state["risk_debate_state"]["count"] >= 3 * self.max_risk_discuss_rounds + ): # 3 rounds of back-and-forth between 3 agents + return "Risk Judge" + if state["risk_debate_state"]["latest_speaker"].startswith("Risky"): + return "Safe Analyst" + if state["risk_debate_state"]["latest_speaker"].startswith("Safe"): + return "Neutral Analyst" + return "Risky Analyst" diff --git a/tradingagents/graph/propagation.py b/tradingagents/graph/propagation.py new file mode 100644 index 0000000..58ebd0a --- /dev/null +++ b/tradingagents/graph/propagation.py @@ -0,0 +1,49 @@ +# TradingAgents/graph/propagation.py + +from typing import Dict, Any +from tradingagents.agents.utils.agent_states import ( + AgentState, + InvestDebateState, + RiskDebateState, +) + + +class Propagator: + """Handles state initialization and propagation through the graph.""" + + def __init__(self, max_recur_limit=100): + """Initialize with configuration parameters.""" + self.max_recur_limit = max_recur_limit + + def create_initial_state( + self, company_name: str, trade_date: str + ) -> Dict[str, Any]: + """Create the initial state for the agent graph.""" + return { + "messages": [("human", company_name)], + "company_of_interest": company_name, + "trade_date": str(trade_date), + "investment_debate_state": InvestDebateState( + {"history": "", "current_response": "", "count": 0} + ), + "risk_debate_state": RiskDebateState( + { + "history": "", + "current_risky_response": "", + "current_safe_response": "", + "current_neutral_response": "", + "count": 0, + } + ), + "market_report": "", + "fundamentals_report": "", + "sentiment_report": "", + "news_report": "", + } + + def get_graph_args(self) -> Dict[str, Any]: + """Get arguments for the graph invocation.""" + return { + "stream_mode": "values", + "config": {"recursion_limit": self.max_recur_limit}, + } diff --git a/tradingagents/graph/reflection.py b/tradingagents/graph/reflection.py new file mode 100644 index 0000000..3330323 --- /dev/null +++ b/tradingagents/graph/reflection.py @@ -0,0 +1,121 @@ +# TradingAgents/graph/reflection.py + +from typing import Dict, Any +from langchain_openai import ChatOpenAI + + +class Reflector: + """Handles reflection on decisions and updating memory.""" + + def __init__(self, quick_thinking_llm: ChatOpenAI): + """Initialize the reflector with an LLM.""" + self.quick_thinking_llm = quick_thinking_llm + self.reflection_system_prompt = self._get_reflection_prompt() + + def _get_reflection_prompt(self) -> str: + """Get the system prompt for reflection.""" + return """ +You are an expert financial analyst tasked with reviewing trading decisions/analysis and providing a comprehensive, step-by-step analysis. +Your goal is to deliver detailed insights into investment decisions and highlight opportunities for improvement, adhering strictly to the following guidelines: + +1. Reasoning: + - For each trading decision, determine whether it was correct or incorrect. A correct decision results in an increase in returns, while an incorrect decision does the opposite. + - Analyze the contributing factors to each success or mistake. Consider: + - Market intelligence. + - Technical indicators. + - Technical signals. + - Price movement analysis. + - Overall market data analysis + - News analysis. + - Social media and sentiment analysis. + - Fundamental data analysis. + - Weight the importance of each factor in the decision-making process. + +2. Improvement: + - For any incorrect decisions, propose revisions to maximize returns. + - Provide a detailed list of corrective actions or improvements, including specific recommendations (e.g., changing a decision from HOLD to BUY on a particular date). + +3. Summary: + - Summarize the lessons learned from the successes and mistakes. + - Highlight how these lessons can be adapted for future trading scenarios and draw connections between similar situations to apply the knowledge gained. + +4. Query: + - Extract key insights from the summary into a concise sentence of no more than 1000 tokens. + - Ensure the condensed sentence captures the essence of the lessons and reasoning for easy reference. + +Adhere strictly to these instructions, and ensure your output is detailed, accurate, and actionable. You will also be given objective descriptions of the market from a price movements, technical indicator, news, and sentiment perspective to provide more context for your analysis. +""" + + def _extract_current_situation(self, current_state: Dict[str, Any]) -> str: + """Extract the current market situation from the state.""" + curr_market_report = current_state["market_report"] + curr_sentiment_report = current_state["sentiment_report"] + curr_news_report = current_state["news_report"] + curr_fundamentals_report = current_state["fundamentals_report"] + + return f"{curr_market_report}\n\n{curr_sentiment_report}\n\n{curr_news_report}\n\n{curr_fundamentals_report}" + + def _reflect_on_component( + self, component_type: str, report: str, situation: str, returns_losses + ) -> str: + """Generate reflection for a component.""" + messages = [ + ("system", self.reflection_system_prompt), + ( + "human", + f"Returns: {returns_losses}\n\nAnalysis/Decision: {report}\n\nObjective Market Reports for Reference: {situation}", + ), + ] + + result = self.quick_thinking_llm.invoke(messages).content + return result + + def reflect_bull_researcher(self, current_state, returns_losses, bull_memory): + """Reflect on bull researcher's analysis and update memory.""" + situation = self._extract_current_situation(current_state) + bull_debate_history = current_state["investment_debate_state"]["bull_history"] + + result = self._reflect_on_component( + "BULL", bull_debate_history, situation, returns_losses + ) + bull_memory.add_situations([(situation, result)]) + + def reflect_bear_researcher(self, current_state, returns_losses, bear_memory): + """Reflect on bear researcher's analysis and update memory.""" + situation = self._extract_current_situation(current_state) + bear_debate_history = current_state["investment_debate_state"]["bear_history"] + + result = self._reflect_on_component( + "BEAR", bear_debate_history, situation, returns_losses + ) + bear_memory.add_situations([(situation, result)]) + + def reflect_trader(self, current_state, returns_losses, trader_memory): + """Reflect on trader's decision and update memory.""" + situation = self._extract_current_situation(current_state) + trader_decision = current_state["trader_investment_plan"] + + result = self._reflect_on_component( + "TRADER", trader_decision, situation, returns_losses + ) + trader_memory.add_situations([(situation, result)]) + + def reflect_invest_judge(self, current_state, returns_losses, invest_judge_memory): + """Reflect on investment judge's decision and update memory.""" + situation = self._extract_current_situation(current_state) + judge_decision = current_state["investment_debate_state"]["judge_decision"] + + result = self._reflect_on_component( + "INVEST JUDGE", judge_decision, situation, returns_losses + ) + invest_judge_memory.add_situations([(situation, result)]) + + def reflect_risk_manager(self, current_state, returns_losses, risk_manager_memory): + """Reflect on risk manager's decision and update memory.""" + situation = self._extract_current_situation(current_state) + judge_decision = current_state["risk_debate_state"]["judge_decision"] + + result = self._reflect_on_component( + "RISK JUDGE", judge_decision, situation, returns_losses + ) + risk_manager_memory.add_situations([(situation, result)]) diff --git a/tradingagents/graph/setup.py b/tradingagents/graph/setup.py new file mode 100644 index 0000000..847c429 --- /dev/null +++ b/tradingagents/graph/setup.py @@ -0,0 +1,205 @@ +# TradingAgents/graph/setup.py + +from typing import Dict, Any +from langchain_openai import ChatOpenAI +from langgraph.graph import END, StateGraph, START +from langgraph.prebuilt import ToolNode + +from tradingagents.agents import * +from tradingagents.agents.utils.agent_states import AgentState +from tradingagents.agents.utils.agent_utils import Toolkit + +from .conditional_logic import ConditionalLogic + + +class GraphSetup: + """Handles the setup and configuration of the agent graph.""" + + def __init__( + self, + quick_thinking_llm: ChatOpenAI, + deep_thinking_llm: ChatOpenAI, + toolkit: Toolkit, + tool_nodes: Dict[str, ToolNode], + bull_memory, + bear_memory, + trader_memory, + invest_judge_memory, + risk_manager_memory, + conditional_logic: ConditionalLogic, + ): + """Initialize with required components.""" + self.quick_thinking_llm = quick_thinking_llm + self.deep_thinking_llm = deep_thinking_llm + self.toolkit = toolkit + self.tool_nodes = tool_nodes + self.bull_memory = bull_memory + self.bear_memory = bear_memory + self.trader_memory = trader_memory + self.invest_judge_memory = invest_judge_memory + self.risk_manager_memory = risk_manager_memory + self.conditional_logic = conditional_logic + + def setup_graph( + self, selected_analysts=["market", "social", "news", "fundamentals"] + ): + """Set up and compile the agent workflow graph. + + Args: + selected_analysts (list): List of analyst types to include. Options are: + - "market": Market analyst + - "social": Social media analyst + - "news": News analyst + - "fundamentals": Fundamentals analyst + """ + if len(selected_analysts) == 0: + raise ValueError("Trading Agents Graph Setup Error: no analysts selected!") + + # Create analyst nodes + analyst_nodes = {} + delete_nodes = {} + tool_nodes = {} + + if "market" in selected_analysts: + analyst_nodes["market"] = create_market_analyst( + self.quick_thinking_llm, self.toolkit + ) + delete_nodes["market"] = create_msg_delete() + tool_nodes["market"] = self.tool_nodes["market"] + + if "social" in selected_analysts: + analyst_nodes["social"] = create_social_media_analyst( + self.quick_thinking_llm, self.toolkit + ) + delete_nodes["social"] = create_msg_delete() + tool_nodes["social"] = self.tool_nodes["social"] + + if "news" in selected_analysts: + analyst_nodes["news"] = create_news_analyst( + self.quick_thinking_llm, self.toolkit + ) + delete_nodes["news"] = create_msg_delete() + tool_nodes["news"] = self.tool_nodes["news"] + + if "fundamentals" in selected_analysts: + analyst_nodes["fundamentals"] = create_fundamentals_analyst( + self.quick_thinking_llm, self.toolkit + ) + delete_nodes["fundamentals"] = create_msg_delete() + tool_nodes["fundamentals"] = self.tool_nodes["fundamentals"] + + # Create researcher and manager nodes + bull_researcher_node = create_bull_researcher( + self.quick_thinking_llm, self.bull_memory + ) + bear_researcher_node = create_bear_researcher( + self.quick_thinking_llm, self.bear_memory + ) + research_manager_node = create_research_manager( + self.deep_thinking_llm, self.invest_judge_memory + ) + trader_node = create_trader(self.quick_thinking_llm, self.trader_memory) + + # Create risk analysis nodes + risky_analyst = create_risky_debator(self.quick_thinking_llm) + neutral_analyst = create_neutral_debator(self.quick_thinking_llm) + safe_analyst = create_safe_debator(self.quick_thinking_llm) + risk_manager_node = create_risk_manager( + self.deep_thinking_llm, self.risk_manager_memory + ) + + # Create workflow + workflow = StateGraph(AgentState) + + # Add analyst nodes to the graph + for analyst_type, node in analyst_nodes.items(): + workflow.add_node(f"{analyst_type.capitalize()} Analyst", node) + workflow.add_node( + f"Msg Clear {analyst_type.capitalize()}", delete_nodes[analyst_type] + ) + workflow.add_node(f"tools_{analyst_type}", tool_nodes[analyst_type]) + + # Add other nodes + workflow.add_node("Bull Researcher", bull_researcher_node) + workflow.add_node("Bear Researcher", bear_researcher_node) + workflow.add_node("Research Manager", research_manager_node) + workflow.add_node("Trader", trader_node) + workflow.add_node("Risky Analyst", risky_analyst) + workflow.add_node("Neutral Analyst", neutral_analyst) + workflow.add_node("Safe Analyst", safe_analyst) + workflow.add_node("Risk Judge", risk_manager_node) + + # Define edges + # Start with the first analyst + first_analyst = selected_analysts[0] + workflow.add_edge(START, f"{first_analyst.capitalize()} Analyst") + + # Connect analysts in sequence + for i, analyst_type in enumerate(selected_analysts): + current_analyst = f"{analyst_type.capitalize()} Analyst" + current_tools = f"tools_{analyst_type}" + current_clear = f"Msg Clear {analyst_type.capitalize()}" + + # Add conditional edges for current analyst + workflow.add_conditional_edges( + current_analyst, + getattr(self.conditional_logic, f"should_continue_{analyst_type}"), + [current_tools, current_clear], + ) + workflow.add_edge(current_tools, current_analyst) + + # Connect to next analyst or to Bull Researcher if this is the last analyst + if i < len(selected_analysts) - 1: + next_analyst = f"{selected_analysts[i+1].capitalize()} Analyst" + workflow.add_edge(current_clear, next_analyst) + else: + workflow.add_edge(current_clear, "Bull Researcher") + + # Add remaining edges + workflow.add_conditional_edges( + "Bull Researcher", + self.conditional_logic.should_continue_debate, + { + "Bear Researcher": "Bear Researcher", + "Research Manager": "Research Manager", + }, + ) + workflow.add_conditional_edges( + "Bear Researcher", + self.conditional_logic.should_continue_debate, + { + "Bull Researcher": "Bull Researcher", + "Research Manager": "Research Manager", + }, + ) + workflow.add_edge("Research Manager", "Trader") + workflow.add_edge("Trader", "Risky Analyst") + workflow.add_conditional_edges( + "Risky Analyst", + self.conditional_logic.should_continue_risk_analysis, + { + "Safe Analyst": "Safe Analyst", + "Risk Judge": "Risk Judge", + }, + ) + workflow.add_conditional_edges( + "Safe Analyst", + self.conditional_logic.should_continue_risk_analysis, + { + "Neutral Analyst": "Neutral Analyst", + "Risk Judge": "Risk Judge", + }, + ) + workflow.add_conditional_edges( + "Neutral Analyst", + self.conditional_logic.should_continue_risk_analysis, + { + "Risky Analyst": "Risky Analyst", + "Risk Judge": "Risk Judge", + }, + ) + + workflow.add_edge("Risk Judge", END) + + # Compile and return + return workflow.compile() diff --git a/tradingagents/graph/signal_processing.py b/tradingagents/graph/signal_processing.py new file mode 100644 index 0000000..903e852 --- /dev/null +++ b/tradingagents/graph/signal_processing.py @@ -0,0 +1,31 @@ +# TradingAgents/graph/signal_processing.py + +from langchain_openai import ChatOpenAI + + +class SignalProcessor: + """Processes trading signals to extract actionable decisions.""" + + def __init__(self, quick_thinking_llm: ChatOpenAI): + """Initialize with an LLM for processing.""" + self.quick_thinking_llm = quick_thinking_llm + + def process_signal(self, full_signal: str) -> str: + """ + Process a full trading signal to extract the core decision. + + Args: + full_signal: Complete trading signal text + + Returns: + Extracted decision (BUY, SELL, or HOLD) + """ + messages = [ + ( + "system", + "You are an efficient assistant designed to analyze paragraphs or financial reports provided by a group of analysts. Your task is to extract the investment decision: SELL, BUY, or HOLD. Provide only the extracted decision (SELL, BUY, or HOLD) as your output, without adding any additional text or information.", + ), + ("human", full_signal), + ] + + return self.quick_thinking_llm.invoke(messages).content diff --git a/tradingagents/graph/trading_graph.py b/tradingagents/graph/trading_graph.py new file mode 100644 index 0000000..bbd4507 --- /dev/null +++ b/tradingagents/graph/trading_graph.py @@ -0,0 +1,243 @@ +# TradingAgents/graph/trading_graph.py + +import os +from pathlib import Path +import json +from datetime import date +from typing import Dict, Any, Tuple, List, Optional + +from langchain_openai import ChatOpenAI +from langgraph.prebuilt import ToolNode + +from tradingagents.agents import * +from tradingagents.default_config import DEFAULT_CONFIG +from tradingagents.agents.utils.memory import FinancialSituationMemory +from tradingagents.agents.utils.agent_states import ( + AgentState, + InvestDebateState, + RiskDebateState, +) +from tradingagents.dataflows.interface import set_config + +from .conditional_logic import ConditionalLogic +from .setup import GraphSetup +from .propagation import Propagator +from .reflection import Reflector +from .signal_processing import SignalProcessor + + +class TradingAgentsGraph: + """Main class that orchestrates the trading agents framework.""" + + def __init__( + self, + selected_analysts=["market", "social", "news", "fundamentals"], + debug=False, + config: Dict[str, Any] = None, + ): + """Initialize the trading agents graph and components. + + Args: + selected_analysts: List of analyst types to include + debug: Whether to run in debug mode + config: Configuration dictionary. If None, uses default config + """ + self.debug = debug + self.config = config or DEFAULT_CONFIG + + # Update the interface's config + set_config(self.config) + + # Create necessary directories + os.makedirs( + os.path.join(self.config["project_dir"], "dataflows/data_cache"), + exist_ok=True, + ) + + # Initialize LLMs + self.deep_thinking_llm = ChatOpenAI(model=self.config["deep_think_llm"]) + self.quick_thinking_llm = ChatOpenAI( + model=self.config["quick_think_llm"], temperature=0.1 + ) + self.toolkit = Toolkit(config=self.config) + + # Initialize memories + self.bull_memory = FinancialSituationMemory("bull_memory") + self.bear_memory = FinancialSituationMemory("bear_memory") + self.trader_memory = FinancialSituationMemory("trader_memory") + self.invest_judge_memory = FinancialSituationMemory("invest_judge_memory") + self.risk_manager_memory = FinancialSituationMemory("risk_manager_memory") + + # Create tool nodes + self.tool_nodes = self._create_tool_nodes() + + # Initialize components + self.conditional_logic = ConditionalLogic() + self.graph_setup = GraphSetup( + self.quick_thinking_llm, + self.deep_thinking_llm, + self.toolkit, + self.tool_nodes, + self.bull_memory, + self.bear_memory, + self.trader_memory, + self.invest_judge_memory, + self.risk_manager_memory, + self.conditional_logic, + ) + + self.propagator = Propagator() + self.reflector = Reflector(self.quick_thinking_llm) + self.signal_processor = SignalProcessor(self.quick_thinking_llm) + + # State tracking + self.curr_state = None + self.ticker = None + self.log_states_dict = {} # date to full state dict + + # Set up the graph + self.graph = self.graph_setup.setup_graph(selected_analysts) + + def _create_tool_nodes(self) -> Dict[str, ToolNode]: + """Create tool nodes for different data sources.""" + return { + "market": ToolNode( + [ + # online tools + self.toolkit.get_YFin_data_online, + self.toolkit.get_stockstats_indicators_report_online, + # offline tools + self.toolkit.get_YFin_data, + self.toolkit.get_stockstats_indicators_report, + ] + ), + "social": ToolNode( + [ + # online tools + self.toolkit.get_stock_news_openai, + # offline tools + self.toolkit.get_reddit_stock_info, + ] + ), + "news": ToolNode( + [ + # online tools + self.toolkit.get_global_news_openai, + self.toolkit.get_google_news, + # offline tools + self.toolkit.get_finnhub_news, + self.toolkit.get_reddit_news, + ] + ), + "fundamentals": ToolNode( + [ + # online tools + self.toolkit.get_fundamentals_openai, + # offline tools + self.toolkit.get_finnhub_company_insider_sentiment, + self.toolkit.get_finnhub_company_insider_transactions, + self.toolkit.get_simfin_balance_sheet, + self.toolkit.get_simfin_cashflow, + self.toolkit.get_simfin_income_stmt, + ] + ), + } + + def propagate(self, company_name, trade_date): + """Run the trading agents graph for a company on a specific date.""" + + self.ticker = company_name + + # Initialize state + init_agent_state = self.propagator.create_initial_state( + company_name, trade_date + ) + args = self.propagator.get_graph_args() + + if self.debug: + # Debug mode with tracing + trace = [] + for chunk in self.graph.stream(init_agent_state, **args): + if len(chunk["messages"]) == 0: + pass + else: + chunk["messages"][-1].pretty_print() + trace.append(chunk) + + final_state = trace[-1] + else: + # Standard mode without tracing + final_state = self.graph.invoke(init_agent_state, **args) + + # Store current state for reflection + self.curr_state = final_state + + # Log state + self._log_state(trade_date, final_state) + + # Return decision and processed signal + return final_state, self.process_signal(final_state["final_trade_decision"]) + + def _log_state(self, trade_date, final_state): + """Log the final state to a JSON file.""" + self.log_states_dict[str(trade_date)] = { + "company_of_interest": final_state["company_of_interest"], + "trade_date": final_state["trade_date"], + "market_report": final_state["market_report"], + "sentiment_report": final_state["sentiment_report"], + "news_report": final_state["news_report"], + "fundamentals_report": final_state["fundamentals_report"], + "investment_debate_state": { + "bull_history": final_state["investment_debate_state"]["bull_history"], + "bear_history": final_state["investment_debate_state"]["bear_history"], + "history": final_state["investment_debate_state"]["history"], + "current_response": final_state["investment_debate_state"][ + "current_response" + ], + "judge_decision": final_state["investment_debate_state"][ + "judge_decision" + ], + }, + "trader_investment_decision": final_state["trader_investment_plan"], + "risk_debate_state": { + "risky_history": final_state["risk_debate_state"]["risky_history"], + "safe_history": final_state["risk_debate_state"]["safe_history"], + "neutral_history": final_state["risk_debate_state"]["neutral_history"], + "history": final_state["risk_debate_state"]["history"], + "judge_decision": final_state["risk_debate_state"]["judge_decision"], + }, + "investment_plan": final_state["investment_plan"], + "final_trade_decision": final_state["final_trade_decision"], + } + + # Save to file + directory = Path(f"eval_results/{self.ticker}/TradingAgentsStrategy_logs/") + directory.mkdir(parents=True, exist_ok=True) + + with open( + f"eval_results/{self.ticker}/TradingAgentsStrategy_logs/full_states_log.json", + "w", + ) as f: + json.dump(self.log_states_dict, f, indent=4) + + def reflect_and_remember(self, returns_losses): + """Reflect on decisions and update memory based on returns.""" + self.reflector.reflect_bull_researcher( + self.curr_state, returns_losses, self.bull_memory + ) + self.reflector.reflect_bear_researcher( + self.curr_state, returns_losses, self.bear_memory + ) + self.reflector.reflect_trader( + self.curr_state, returns_losses, self.trader_memory + ) + self.reflector.reflect_invest_judge( + self.curr_state, returns_losses, self.invest_judge_memory + ) + self.reflector.reflect_risk_manager( + self.curr_state, returns_losses, self.risk_manager_memory + ) + + def process_signal(self, full_signal): + """Process a signal to extract the core decision.""" + return self.signal_processor.process_signal(full_signal)