Initial commit: TradingAgents KR Web App

Features:
- Korean stock data via KRX (pykrx, Naver Finance)
- AI-powered stock analysis
- Streamlit web interface

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.env.example

@@ -0,0 +1,2 @@
+ALPHA_VANTAGE_API_KEY=alpha_vantage_api_key_placeholder
+OPENAI_API_KEY=openai_api_key_placeholder

.gitattributes

@@ -0,0 +1,4 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,18 @@
+.venv
+venv/
+results
+env/
+__pycache__/
+.DS_Store
+*.csv
+src/
+eval_results/
+eval_data/
+*.egg-info/
+.env
+*.backup
+README.md
+plan.md
+.claude/
+temp_forecast/
+

.python-version

@@ -0,0 +1 @@
+3.10

.streamlit/config.toml

@@ -0,0 +1,11 @@
+[theme]
+primaryColor = "#1E88E5"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif"
+
+[server]
+headless = true
+port = 8501
+enableCORS = false

.streamlit/secrets.toml.example

@@ -0,0 +1,5 @@
+# Streamlit Cloud Secrets 설정 예제
+# Streamlit Cloud 대시보드에서 Settings > Secrets에 아래 내용을 입력하세요
+
+OPENAI_API_KEY = "your-openai-api-key"
+ALPHA_VANTAGE_API_KEY = "your-alpha-vantage-api-key"

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.

README.md

@@ -0,0 +1,34 @@
+---
+title: TradingAgents AI 주식 분석
+emoji: 📈
+colorFrom: blue
+colorTo: indigo
+sdk: streamlit
+sdk_version: 1.40.0
+app_file: app.py
+pinned: false
+license: cc-by-sa-4.0
+---
+
+# TradingAgents - AI 주식 분석 시스템
+
+AI 에이전트가 협업하여 미국/한국 주식을 분석하는 시스템입니다.
+
+## 주요 기능
+
+- 🇺🇸 **미국 주식**: NYSE, NASDAQ (Yahoo Finance)
+- 🇰🇷 **한국 주식**: 코스피, 코스닥 (pykrx, FinanceDataReader)
+- 🤖 **AI 분석**: 펀더멘탈, 센티먼트, 뉴스, 기술적 분석
+- 📊 **차트**: 캔들스틱 + 거래량 시각화
+
+## 로그인 정보
+
+시스템 관리자에게 문의하세요.
+
+## 면책 조항
+
+⚠️ 본 시스템은 연구 및 교육 목적으로만 사용됩니다. 투자 조언이 아닙니다.
+
+## 크레딧
+
+Based on [TradingAgents](https://github.com/TauricResearch/TradingAgents) by Tauric Research

app.py

@@ -0,0 +1,187 @@
+"""
+TradingAgents 웹 애플리케이션
+AI 기반 미국/한국 주식 분석 시스템 - 멀티페이지 진입점
+"""
+
+import streamlit as st
+import hashlib
+import sys
+import os
+
+# .env 파일 로드
+from dotenv import load_dotenv
+load_dotenv()
+
+# 프로젝트 경로 추가
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# 페이지 설정
+st.set_page_config(
+    page_title="TradingAgents - AI 주식 분석",
+    page_icon="📈",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# 커스텀 CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1E88E5;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background-color: #f0f2f6;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+    }
+    .profit-positive {
+        color: #e53935;
+        font-weight: bold;
+    }
+    .profit-negative {
+        color: #1e88e5;
+        font-weight: bold;
+    }
+    .stock-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 15px;
+        padding: 1.5rem;
+        color: white;
+        margin: 0.5rem 0;
+    }
+
+    /* 사이드바 폰트 크기 증가 */
+    [data-testid="stSidebarNav"] {
+        padding-top: 1rem;
+    }
+    [data-testid="stSidebarNav"] span {
+        font-size: 1.1rem !important;
+        font-weight: 500 !important;
+    }
+
+    /* app 메뉴 숨기기 (첫 번째 항목) */
+    [data-testid="stSidebarNav"] > ul > li:first-child {
+        display: none;
+    }
+
+    .stButton>button {
+        width: 100%;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# 인증 정보 (보안을 위해 해시 처리)
+VALID_CREDENTIALS = {
+    "newmind68": hashlib.sha256("@#sksk2739".encode()).hexdigest()
+}
+
+
+def check_password(username: str, password: str) -> bool:
+    """사용자명과 비밀번호 검증"""
+    if username in VALID_CREDENTIALS:
+        hashed = hashlib.sha256(password.encode()).hexdigest()
+        return hashed == VALID_CREDENTIALS[username]
+    return False
+
+
+def login_page():
+    """로그인 페이지 표시"""
+    st.markdown('<p class="main-header">📈 TradingAgents</p>', unsafe_allow_html=True)
+    st.markdown('<p class="sub-header">AI 기반 주식 분석 시스템</p>', unsafe_allow_html=True)
+
+    col1, col2, col3 = st.columns([1, 2, 1])
+
+    with col2:
+        st.markdown("### 로그인")
+
+        with st.form("login_form"):
+            username = st.text_input("아이디", placeholder="아이디를 입력하세요")
+            password = st.text_input("비밀번호", type="password", placeholder="비밀번호를 입력하세요")
+            submit = st.form_submit_button("로그인", type="primary")
+
+            if submit:
+                if check_password(username, password):
+                    st.session_state.authenticated = True
+                    st.session_state.username = username
+                    st.rerun()
+                else:
+                    st.error("아이디 또는 비밀번호가 올바르지 않습니다")
+
+        st.markdown("---")
+        st.markdown("""
+        <div style="text-align: center; color: #888; font-size: 0.9rem;">
+        <p>AI 에이전트가 다양한 관점에서 주식을 분석합니다:</p>
+        <p>📊 펀더멘탈 | 📰 뉴스 | 💬 센티먼트 | 📈 기술적 분석</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+
+def main_redirect():
+    """로그인 후 홈으로 리다이렉트 안내"""
+    st.markdown('<p class="main-header">📈 TradingAgents</p>', unsafe_allow_html=True)
+
+    # 사이드바에 사용자 정보
+    with st.sidebar:
+        st.markdown(f"### 👤 {st.session_state.username}님")
+        st.markdown("---")
+
+        if st.button("🚪 로그아웃", type="secondary"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+
+    # 메인 콘텐츠
+    st.markdown("### 환영합니다!")
+    st.info("👈 왼쪽 사이드바에서 메뉴를 선택하세요")
+
+    st.markdown("---")
+    st.markdown("""
+    ### 📌 주요 메뉴 안내
+
+    | 메뉴 | 설명 |
+    |------|------|
+    | **🏠 홈** | 포트폴리오 요약 및 대시보드 |
+    | **💼 나의 주식** | 보유 종목 관리, 상세 분석, AI 예측 |
+    | **🔍 종목 탐색** | 새로운 종목 검색 및 관심종목 관리 |
+    | **📊 분석 리포트** | AI 분석 히스토리 조회 |
+    | **⚙️ 설정** | 프로필 및 앱 설정 |
+    """)
+
+    st.markdown("---")
+    st.markdown("""
+    ### 🚀 시작하기
+
+    1. **포트폴리오 구성**: '나의 주식' 메뉴에서 보유 종목을 추가하세요
+    2. **AI 분석 실행**: 종목을 선택하고 AI 분석을 실행하세요
+    3. **인사이트 확인**: 대시보드에서 전체 현황을 확인하세요
+    """)
+
+
+def main():
+    """메인 진입점"""
+    # 세션 상태 초기화
+    if 'authenticated' not in st.session_state:
+        st.session_state.authenticated = False
+    if 'username' not in st.session_state:
+        st.session_state.username = None
+
+    # 적절한 페이지 표시
+    if st.session_state.authenticated:
+        main_redirect()
+    else:
+        login_page()
+
+
+if __name__ == "__main__":
+    main()

data/users/newmind68/portfolio.json

@@ -0,0 +1,17 @@
+{
+  "user_id": "newmind68",
+  "created_at": "2026-01-03T21:10:26.376414",
+  "updated_at": "2026-01-03T21:10:26.376472",
+  "holdings": [
+    {
+      "id": "3d4a7da5-27ba-48cf-b708-0ff6db31c1f8",
+      "symbol": "304100",
+      "company_name": "솔트룩스",
+      "market": "krx",
+      "buy_price": 1300.0,
+      "quantity": 7,
+      "buy_date": "2025-01-09",
+      "memo": ""
+    }
+  ]
+}

pages/1_홈.py

@@ -0,0 +1,211 @@
+"""
+홈 대시보드 - 포트폴리오 요약 및 현황
+"""
+import streamlit as st
+import sys
+import os
+from datetime import datetime, timedelta
+
+# 프로젝트 경로 추가
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.portfolio_service import PortfolioService
+from services.stock_service import StockService
+from services.analysis_service import AnalysisService
+
+st.set_page_config(page_title="홈 - TradingAgents", page_icon="🏠", layout="wide")
+
+# 공통 CSS - app 메뉴 숨김 및 사이드바 스타일
+st.markdown("""
+<style>
+    [data-testid="stSidebarNav"] span {
+        font-size: 1.1rem !important;
+        font-weight: 500 !important;
+    }
+    [data-testid="stSidebarNav"] > ul > li:first-child {
+        display: none;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def check_auth():
+    """인증 확인"""
+    if 'authenticated' not in st.session_state or not st.session_state.authenticated:
+        st.warning("로그인이 필요합니다")
+        st.stop()
+    return st.session_state.username
+
+
+def render_portfolio_summary(summary: dict):
+    """포트폴리오 요약 카드 렌더링"""
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric(
+            "총 평가금액",
+            f"{summary['total_current']:,.0f}원",
+            f"{summary['total_profit']:+,.0f}원"
+        )
+
+    with col2:
+        st.metric(
+            "총 투자금액",
+            f"{summary['total_invested']:,.0f}원"
+        )
+
+    with col3:
+        profit_rate = summary['total_profit_rate']
+        st.metric(
+            "총 수익률",
+            f"{profit_rate:+.2f}%"
+        )
+
+    with col4:
+        st.metric(
+            "보유 종목",
+            f"{summary['holdings_count']}개"
+        )
+
+
+def render_holding_card(holding: dict, current_price: float, profit_info: dict):
+    """개별 종목 카드 렌더링"""
+    profit_rate = profit_info['profit_rate']
+    profit_color = "red" if profit_rate >= 0 else "blue"
+    arrow = "▲" if profit_rate >= 0 else "▼"
+
+    # 시장 플래그
+    flag = "🇰🇷" if holding['market'] == 'krx' else "🇺🇸"
+
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+                border-radius: 10px; padding: 1rem; margin: 0.5rem 0;">
+        <div style="display: flex; justify-content: space-between; align-items: center;">
+            <div>
+                <span style="font-size: 1.2rem; font-weight: bold;">{flag} {holding['company_name']}</span>
+                <span style="color: #666; margin-left: 0.5rem;">({holding['symbol']})</span>
+            </div>
+            <div style="text-align: right;">
+                <div style="font-size: 1.1rem; font-weight: bold;">{current_price:,.0f}원</div>
+                <div style="color: {profit_color};">{arrow} {abs(profit_rate):.2f}%</div>
+            </div>
+        </div>
+        <div style="margin-top: 0.5rem; color: #666; font-size: 0.9rem;">
+            평균단가: {holding['buy_price']:,.0f}원 | 보유: {holding['quantity']:,}주 |
+            평가손익: <span style="color: {profit_color};">{profit_info['profit']:+,.0f}원</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def render_recent_reports(reports: list):
+    """최근 AI 분석 리포트 렌더링"""
+    if not reports:
+        st.info("아직 AI 분석 리포트가 없습니다")
+        return
+
+    for report in reports[:5]:
+        decision = report.get('decision', {})
+        action = decision.get('action', 'N/A') if isinstance(decision, dict) else 'N/A'
+
+        action_color = {
+            'BUY': '🟢', 'STRONG_BUY': '🟢',
+            'SELL': '🔴', 'STRONG_SELL': '🔴',
+            'HOLD': '🟡'
+        }.get(action.upper(), '⚪')
+
+        analysis_date = report.get('analysis_date', '')
+        company_name = report.get('company_name', report.get('symbol', ''))
+
+        st.markdown(f"""
+        <div style="padding: 0.5rem; border-bottom: 1px solid #eee;">
+            {action_color} <strong>{company_name}</strong> ({report.get('symbol', '')})
+            <span style="color: #666; margin-left: 1rem;">{analysis_date}</span>
+            <span style="float: right;">{action}</span>
+        </div>
+        """, unsafe_allow_html=True)
+
+
+def main():
+    username = check_auth()
+
+    # 사이드바
+    with st.sidebar:
+        st.markdown(f"### 👤 {username}님")
+        st.markdown("---")
+
+        if st.button("🚪 로그아웃", type="secondary"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+
+    # 서비스 초기화
+    portfolio_service = PortfolioService(username)
+    stock_service = StockService()
+    analysis_service = AnalysisService(username)
+
+    # 헤더
+    st.markdown("# 🏠 대시보드")
+    st.markdown("---")
+
+    # 포트폴리오 데이터 로드
+    holdings = portfolio_service.get_all_holdings()
+
+    if not holdings:
+        st.info("👋 아직 등록된 종목이 없습니다. '나의 주식' 메뉴에서 종목을 추가해보세요!")
+
+        # 빠른 시작 가이드
+        st.markdown("""
+        ### 🚀 시작하기
+
+        1. **왼쪽 메뉴**에서 **'나의 주식'**을 선택하세요
+        2. **'종목 추가'** 버튼을 클릭하세요
+        3. 종목 코드, 매수가, 수량을 입력하세요
+
+        ### 💡 팁
+        - 한국 주식: 6자리 숫자 (예: 005930 삼성전자)
+        - 미국 주식: 티커 심볼 (예: AAPL, NVDA)
+        """)
+    else:
+        # 현재가 조회
+        with st.spinner("현재가 조회 중..."):
+            symbols = [h['symbol'] for h in holdings]
+            current_prices = stock_service.get_current_prices(symbols)
+
+        # 포트폴리오 요약
+        st.markdown("### 📊 포트폴리오 요약")
+        summary = portfolio_service.calculate_portfolio_summary(current_prices)
+        render_portfolio_summary(summary)
+
+        st.markdown("---")
+
+        # 보유 종목 목록
+        st.markdown("### 💼 보유 종목")
+
+        cols = st.columns(2)
+        for i, holding in enumerate(holdings):
+            current_price = current_prices.get(holding['symbol'], holding['buy_price'])
+            profit_info = portfolio_service.calculate_profit(holding, current_price)
+
+            with cols[i % 2]:
+                render_holding_card(holding, current_price, profit_info)
+
+        st.markdown("---")
+
+    # 최근 AI 분석 리포트
+    st.markdown("### 🤖 최근 AI 분석 리포트")
+    reports = analysis_service.get_reports(limit=5)
+    render_recent_reports(reports)
+
+    # 푸터
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; color: #888; font-size: 0.8rem;">
+        TradingAgents - AI 기반 주식 분석 시스템<br>
+        ⚠️ 본 시스템은 투자 참고용이며, 투자 결정에 대한 책임은 사용자에게 있습니다.
+    </div>
+    """, unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()

pages/2_나의주식.py

@@ -0,0 +1,399 @@
+"""
+나의 주식 - 포트폴리오 관리, 종목 상세, AI 분석
+메인 기능 페이지
+"""
+import streamlit as st
+import sys
+import os
+from datetime import datetime, timedelta
+import pandas as pd
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.portfolio_service import PortfolioService
+from services.stock_service import StockService
+from services.analysis_service import AnalysisService
+
+st.set_page_config(page_title="나의 주식 - TradingAgents", page_icon="💼", layout="wide")
+
+# 공통 CSS - app 메뉴 숨김 및 사이드바 스타일
+st.markdown("""
+<style>
+    [data-testid="stSidebarNav"] span {
+        font-size: 1.1rem !important;
+        font-weight: 500 !important;
+    }
+    [data-testid="stSidebarNav"] > ul > li:first-child {
+        display: none;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def check_auth():
+    if 'authenticated' not in st.session_state or not st.session_state.authenticated:
+        st.warning("로그인이 필요합니다")
+        st.stop()
+    return st.session_state.username
+
+
+def render_add_holding_form(portfolio_service: PortfolioService, stock_service: StockService):
+    """종목 추가 폼"""
+    st.markdown("### ➕ 종목 추가")
+
+    with st.form("add_holding_form"):
+        col1, col2 = st.columns(2)
+
+        with col1:
+            market = st.radio("시장", ["한국 (KRX)", "미국"], horizontal=True)
+            if market == "한국 (KRX)":
+                symbol = st.text_input("종목 코드", placeholder="예: 005930")
+                st.caption("6자리 종목 코드를 입력하세요")
+            else:
+                symbol = st.text_input("티커 심볼", placeholder="예: AAPL")
+                st.caption("티커 심볼을 입력하세요")
+
+        with col2:
+            buy_price = st.number_input("매수 단가", min_value=0.0, step=100.0)
+            quantity = st.number_input("매수 수량", min_value=1, step=1)
+            buy_date = st.date_input("매수일", datetime.now())
+
+        memo = st.text_input("메모 (선택)", placeholder="투자 메모를 입력하세요")
+
+        submitted = st.form_submit_button("종목 추가", type="primary")
+
+        if submitted and symbol and buy_price > 0 and quantity > 0:
+            # 회사 정보 조회
+            company_name, market_info = stock_service.get_company_info(symbol)
+            market_code = "krx" if stock_service.is_korean_stock(symbol) else "us"
+
+            # 포트폴리오에 추가
+            portfolio_service.add_holding(
+                symbol=symbol,
+                company_name=company_name,
+                market=market_code,
+                buy_price=buy_price,
+                quantity=quantity,
+                buy_date=buy_date.strftime("%Y-%m-%d"),
+                memo=memo
+            )
+
+            st.success(f"✅ {company_name} ({symbol})이(가) 추가되었습니다!")
+            st.rerun()
+
+
+def render_holdings_table(holdings: list, current_prices: dict,
+                           portfolio_service: PortfolioService):
+    """보유 종목 테이블"""
+    if not holdings:
+        st.info("등록된 종목이 없습니다. 위에서 종목을 추가해보세요!")
+        return
+
+    # 데이터 준비
+    data = []
+    for h in holdings:
+        current_price = current_prices.get(h['symbol'], h['buy_price'])
+        profit_info = portfolio_service.calculate_profit(h, current_price)
+        buy_date_str = h.get('buy_date', '-')
+
+        data.append({
+            "종목": f"{h['company_name']} ({h['symbol']})",
+            "시장": "🇰🇷" if h['market'] == 'krx' else "🇺🇸",
+            "매수일": buy_date_str,
+            "매수단가": f"{h['buy_price']:,.0f}",
+            "현재가": f"{current_price:,.0f}",
+            "수량": h['quantity'],
+            "평가금액": f"{profit_info['current_value']:,.0f}",
+            "수익률": f"{profit_info['profit_rate']:+.2f}%",
+            "평가손익": f"{profit_info['profit']:+,.0f}",
+            "symbol": h['symbol']
+        })
+
+    df = pd.DataFrame(data)
+
+    # 테이블 표시
+    st.dataframe(
+        df[["종목", "시장", "매수일", "매수단가", "현재가", "수량", "평가금액", "수익률", "평가손익"]],
+        use_container_width=True,
+        hide_index=True
+    )
+
+    # 종목 삭제
+    st.markdown("---")
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        symbols_to_delete = [f"{h['company_name']} ({h['symbol']})" for h in holdings]
+        selected = st.selectbox("삭제할 종목 선택", ["선택하세요"] + symbols_to_delete)
+    with col2:
+        st.markdown("<br>", unsafe_allow_html=True)
+        if st.button("🗑️ 삭제", type="secondary"):
+            if selected != "선택하세요":
+                # 심볼 추출
+                symbol = selected.split("(")[-1].replace(")", "")
+                portfolio_service.remove_holding(symbol)
+                st.success(f"✅ {selected} 삭제되었습니다")
+                st.rerun()
+
+
+def render_stock_detail(holdings: list, stock_service: StockService,
+                        portfolio_service: PortfolioService):
+    """종목 상세 보기"""
+    if not holdings:
+        st.info("먼저 포트폴리오에 종목을 추가해주세요")
+        return
+
+    # 종목 선택
+    stock_options = {f"{h['company_name']} ({h['symbol']})": h for h in holdings}
+    selected_name = st.selectbox("종목 선택", list(stock_options.keys()))
+    holding = stock_options[selected_name]
+
+    # 매수일 정보 확인
+    buy_date_str = holding.get('buy_date', '')
+    has_buy_date = bool(buy_date_str)
+
+    # 기간 선택
+    col1, col2, col3 = st.columns([1, 1, 2])
+    with col1:
+        period_options = ["매수일부터", "1개월", "3개월", "6개월", "1년"] if has_buy_date else ["1개월", "3개월", "6개월", "1년"]
+        period = st.selectbox("기간", period_options)
+    with col2:
+        st.markdown("<br>", unsafe_allow_html=True)
+        refresh = st.button("🔄 새로고침")
+
+    # 기간 계산
+    end_date = datetime.now()
+    if period == "매수일부터" and has_buy_date:
+        start_date = datetime.strptime(buy_date_str, "%Y-%m-%d")
+        holding_days = (end_date - start_date).days
+        st.caption(f"📅 매수일: {buy_date_str} (보유 {holding_days}일)")
+    else:
+        period_days = {"1개월": 30, "3개월": 90, "6개월": 180, "1년": 365}
+        start_date = end_date - timedelta(days=period_days[period])
+
+    # 데이터 조회
+    with st.spinner("데이터 조회 중..."):
+        df, error = stock_service.get_stock_data(
+            holding['symbol'],
+            start_date.strftime("%Y-%m-%d"),
+            end_date.strftime("%Y-%m-%d")
+        )
+
+    if error:
+        st.error(f"데이터 조회 오류: {error}")
+        return
+
+    if df is None or df.empty:
+        st.warning("데이터가 없습니다")
+        return
+
+    # 주가 차트
+    st.markdown("### 📈 주가 차트")
+    fig = stock_service.plot_candlestick(df, holding['symbol'], holding['company_name'])
+    if fig:
+        st.plotly_chart(fig, use_container_width=True)
+
+    # 주요 지표
+    metrics = stock_service.get_stock_metrics(df)
+    if metrics:
+        st.markdown("### 📊 주요 지표")
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("현재가", f"{metrics['current_price']:,.0f}원",
+                     f"{metrics['change_rate']:+.2f}%")
+        with col2:
+            st.metric("기간 최고가", f"{metrics['period_high']:,.0f}원")
+        with col3:
+            st.metric("기간 최저가", f"{metrics['period_low']:,.0f}원")
+        with col4:
+            st.metric("데이터 수", f"{metrics['data_count']}일")
+
+    # 나의 투자 현황
+    st.markdown("### 💰 나의 투자 현황")
+    current_price = metrics.get('current_price', holding['buy_price'])
+    profit_info = portfolio_service.calculate_profit(holding, current_price)
+
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("매수일", buy_date_str if has_buy_date else "-")
+    with col2:
+        st.metric("평균 매수가", f"{holding['buy_price']:,.0f}원")
+    with col3:
+        st.metric("보유 수량", f"{holding['quantity']:,}주")
+    with col4:
+        profit_color = "normal" if profit_info['profit'] >= 0 else "inverse"
+        st.metric("평가 손익", f"{profit_info['profit']:+,.0f}원",
+                 f"{profit_info['profit_rate']:+.2f}%", delta_color=profit_color)
+
+    # 기술적 지표
+    with st.expander("📉 기술적 지표 보기"):
+        indicator = st.selectbox("지표 선택", ["RSI", "MACD", "볼린저밴드"])
+        try:
+            indicator_df, err = stock_service.get_technical_indicators(
+                holding['symbol'],
+                start_date.strftime("%Y-%m-%d"),
+                end_date.strftime("%Y-%m-%d")
+            )
+            if indicator_df is not None:
+                indicator_type = {"RSI": "RSI", "MACD": "MACD", "볼린저밴드": "BB"}[indicator]
+                indicator_fig = stock_service.plot_indicators(indicator_df, indicator_type)
+                if indicator_fig:
+                    st.plotly_chart(indicator_fig, use_container_width=True)
+        except Exception as e:
+            st.warning(f"기술적 지표 조회 실패: {e}")
+
+    # 원본 데이터
+    with st.expander("📋 원본 데이터 보기"):
+        st.dataframe(df.tail(20), use_container_width=True)
+
+
+def render_ai_analysis(holdings: list, analysis_service: AnalysisService):
+    """AI 분석 탭"""
+    st.markdown("""
+    ### 🤖 AI 기반 종목 분석
+
+    TradingAgents는 여러 AI 에이전트가 협업하여 주식을 분석합니다:
+    - **펀더멘탈 분석가**: 재무제표, 실적, 밸류에이션
+    - **센티먼트 분석가**: 시장 심리 및 소셜 미디어
+    - **뉴스 분석가**: 최신 뉴스 및 이벤트
+    - **기술적 분석가**: 가격 패턴 및 지표
+    - **Bull vs Bear 토론**: 강세론과 약세론 토론 후 합의
+    """)
+
+    st.markdown("---")
+
+    if not holdings:
+        st.info("먼저 포트폴리오에 종목을 추가해주세요")
+        return
+
+    # 종목 선택
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        stock_options = {f"{h['company_name']} ({h['symbol']})": h['symbol'] for h in holdings}
+        selected = st.selectbox("분석할 종목", list(stock_options.keys()))
+        symbol = stock_options[selected]
+    with col2:
+        analysis_date = st.date_input("분석 기준일", datetime.now())
+
+    # 최근 분석 결과 표시
+    latest_report = analysis_service.get_latest_report(symbol)
+    if latest_report:
+        st.markdown("#### 📋 최근 분석 결과")
+        st.info(f"마지막 분석일: {latest_report.get('analysis_date', 'N/A')}")
+
+        decision = latest_report.get('decision', {})
+        if isinstance(decision, dict):
+            action = decision.get('action', 'N/A')
+            confidence = decision.get('confidence', 0)
+            st.markdown(f"**투자 의견**: {action} (신뢰도: {confidence}%)")
+
+    # 분석 실행 버튼
+    st.markdown("---")
+    if st.button("🚀 AI 분석 시작", type="primary"):
+        st.warning("⚠️ AI 분석은 OpenAI API를 사용하며 비용이 발생할 수 있습니다.")
+        st.info("⏱️ 분석에 3-5분이 소요됩니다...")
+
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+
+        def progress_callback(msg):
+            status_text.text(msg)
+
+        with st.spinner("AI 에이전트 분석 중..."):
+            progress_bar.progress(30)
+            decision, error = analysis_service.run_analysis(
+                symbol,
+                analysis_date.strftime("%Y-%m-%d"),
+                progress_callback
+            )
+            progress_bar.progress(100)
+
+        if error:
+            st.error(f"분석 오류: {error}")
+        elif decision:
+            st.success("✅ 분석 완료!")
+            st.markdown("### 📊 분석 결과")
+
+            # 결과 표시
+            if isinstance(decision, dict):
+                st.json(decision)
+            else:
+                st.write(decision)
+
+            # 한글 리포트
+            korean_report = analysis_service.format_decision_korean(decision)
+            st.markdown(korean_report)
+        else:
+            st.info("분석이 완료되었지만 결과가 반환되지 않았습니다.")
+
+    # 분석 리포트 목록
+    st.markdown("---")
+    st.markdown("#### 📚 이 종목의 분석 기록")
+    reports = analysis_service.get_reports(symbol=symbol, limit=5)
+
+    if reports:
+        for report in reports:
+            col1, col2, col3 = st.columns([2, 1, 1])
+            with col1:
+                st.write(f"📅 {report.get('analysis_date', 'N/A')}")
+            with col2:
+                decision = report.get('decision', {})
+                action = decision.get('action', 'N/A') if isinstance(decision, dict) else 'N/A'
+                st.write(f"**{action}**")
+            with col3:
+                if st.button("삭제", key=f"del_{report.get('report_id', '')}"):
+                    analysis_service.delete_report(symbol, report.get('report_id', ''))
+                    st.rerun()
+    else:
+        st.info("아직 분석 기록이 없습니다")
+
+
+def main():
+    username = check_auth()
+
+    # 사이드바
+    with st.sidebar:
+        st.markdown(f"### 👤 {username}님")
+        st.markdown("---")
+        if st.button("🚪 로그아웃", type="secondary"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+
+    # 서비스 초기화
+    portfolio_service = PortfolioService(username)
+    stock_service = StockService()
+    analysis_service = AnalysisService(username)
+
+    # 헤더
+    st.markdown("# 💼 나의 주식")
+
+    # 탭
+    tab1, tab2, tab3 = st.tabs(["📋 포트폴리오 관리", "📈 종목 상세", "🤖 AI 분석"])
+
+    with tab1:
+        # 종목 추가 폼
+        render_add_holding_form(portfolio_service, stock_service)
+
+        st.markdown("---")
+
+        # 보유 종목 테이블
+        st.markdown("### 📊 보유 종목 현황")
+        holdings = portfolio_service.get_all_holdings()
+
+        with st.spinner("현재가 조회 중..."):
+            symbols = [h['symbol'] for h in holdings]
+            current_prices = stock_service.get_current_prices(symbols) if symbols else {}
+
+        render_holdings_table(holdings, current_prices, portfolio_service)
+
+    with tab2:
+        holdings = portfolio_service.get_all_holdings()
+        render_stock_detail(holdings, stock_service, portfolio_service)
+
+    with tab3:
+        holdings = portfolio_service.get_all_holdings()
+        render_ai_analysis(holdings, analysis_service)
+
+
+if __name__ == "__main__":
+    main()

pages/3_종목탐색.py

@@ -0,0 +1,399 @@
+"""
+종목 탐색 - 주식 검색 및 관심종목 관리
+"""
+import streamlit as st
+import sys
+import os
+from datetime import datetime, timedelta
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.portfolio_service import PortfolioService
+from services.stock_service import StockService
+
+st.set_page_config(page_title="종목 탐색 - TradingAgents", page_icon="🔍", layout="wide")
+
+# 공통 CSS - app 메뉴 숨김 및 사이드바 스타일
+st.markdown("""
+<style>
+    [data-testid="stSidebarNav"] span {
+        font-size: 1.1rem !important;
+        font-weight: 500 !important;
+    }
+    [data-testid="stSidebarNav"] > ul > li:first-child {
+        display: none;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def check_auth():
+    if 'authenticated' not in st.session_state or not st.session_state.authenticated:
+        st.warning("로그인이 필요합니다")
+        st.stop()
+    return st.session_state.username
+
+
+# 인기 종목 데이터
+POPULAR_STOCKS = {
+    "한국": [
+        {"symbol": "005930", "name": "삼성전자"},
+        {"symbol": "000660", "name": "SK하이닉스"},
+        {"symbol": "035720", "name": "카카오"},
+        {"symbol": "051910", "name": "LG화학"},
+        {"symbol": "005380", "name": "현대자동차"},
+        {"symbol": "006400", "name": "삼성SDI"},
+        {"symbol": "035420", "name": "NAVER"},
+        {"symbol": "000270", "name": "기아"},
+    ],
+    "미국": [
+        {"symbol": "AAPL", "name": "Apple"},
+        {"symbol": "NVDA", "name": "NVIDIA"},
+        {"symbol": "MSFT", "name": "Microsoft"},
+        {"symbol": "GOOGL", "name": "Alphabet"},
+        {"symbol": "AMZN", "name": "Amazon"},
+        {"symbol": "TSLA", "name": "Tesla"},
+        {"symbol": "META", "name": "Meta"},
+        {"symbol": "AMD", "name": "AMD"},
+    ]
+}
+
+
+def render_search_result(symbol: str, stock_service: StockService,
+                          portfolio_service: PortfolioService):
+    """검색 결과 표시"""
+    with st.spinner("종목 정보 조회 중..."):
+        company_name, market_info = stock_service.get_company_info(symbol)
+        current_price = stock_service.get_current_price(symbol)
+
+        # 최근 데이터 조회
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=30)
+        df, error = stock_service.get_stock_data(
+            symbol,
+            start_date.strftime("%Y-%m-%d"),
+            end_date.strftime("%Y-%m-%d")
+        )
+
+    if error:
+        st.error(f"조회 오류: {error}")
+        return
+
+    # 결과 표시
+    st.markdown(f"### 📊 {company_name} ({symbol})")
+    st.markdown(f"**시장**: {market_info}")
+
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        # 미니 차트
+        if df is not None and not df.empty:
+            fig = stock_service.plot_mini_chart(df, symbol)
+            if fig:
+                fig.update_layout(height=200)
+                st.plotly_chart(fig, use_container_width=True)
+
+            # 지표
+            metrics = stock_service.get_stock_metrics(df)
+            if metrics:
+                mcol1, mcol2, mcol3 = st.columns(3)
+                with mcol1:
+                    st.metric("현재가", f"{metrics['current_price']:,.0f}원",
+                             f"{metrics['change_rate']:+.2f}%")
+                with mcol2:
+                    st.metric("최고가", f"{metrics['period_high']:,.0f}원")
+                with mcol3:
+                    st.metric("최저가", f"{metrics['period_low']:,.0f}원")
+
+    with col2:
+        st.markdown("#### 빠른 작업")
+
+        # 관심종목 추가
+        watchlist = portfolio_service.get_watchlist()
+        is_in_watchlist = any(s['symbol'] == symbol for s in watchlist)
+
+        if is_in_watchlist:
+            if st.button("⭐ 관심종목에서 제거", key="remove_watch"):
+                portfolio_service.remove_from_watchlist(symbol)
+                st.success("관심종목에서 제거되었습니다")
+                st.rerun()
+        else:
+            target_price = st.number_input("목표가 (선택)", min_value=0.0)
+            notes = st.text_input("메모 (선택)")
+            if st.button("⭐ 관심종목 추가", key="add_watch"):
+                market = "krx" if stock_service.is_korean_stock(symbol) else "us"
+                portfolio_service.add_to_watchlist(
+                    symbol, company_name, market,
+                    target_price if target_price > 0 else None,
+                    notes
+                )
+                st.success("관심종목에 추가되었습니다!")
+                st.rerun()
+
+        st.markdown("---")
+
+        # 포트폴리오 추가
+        holdings = portfolio_service.get_all_holdings()
+        is_in_portfolio = any(h['symbol'] == symbol for h in holdings)
+
+        if is_in_portfolio:
+            st.info("이미 보유 중인 종목입니다")
+        else:
+            with st.form("quick_add_form"):
+                buy_price = st.number_input("매수 단가", min_value=0.0,
+                                           value=float(current_price) if current_price else 0.0)
+                quantity = st.number_input("수량", min_value=1, value=1)
+
+                if st.form_submit_button("💼 포트폴리오에 추가"):
+                    market = "krx" if stock_service.is_korean_stock(symbol) else "us"
+                    portfolio_service.add_holding(
+                        symbol=symbol,
+                        company_name=company_name,
+                        market=market,
+                        buy_price=buy_price,
+                        quantity=quantity,
+                        buy_date=datetime.now().strftime("%Y-%m-%d")
+                    )
+                    st.success("포트폴리오에 추가되었습니다!")
+                    st.rerun()
+
+
+def render_watchlist(portfolio_service: PortfolioService, stock_service: StockService):
+    """관심종목 목록"""
+    watchlist = portfolio_service.get_watchlist()
+
+    if not watchlist:
+        st.info("등록된 관심종목이 없습니다. 종목을 검색하여 추가해보세요!")
+        return
+
+    for stock in watchlist:
+        col1, col2, col3, col4 = st.columns([2, 1, 1, 1])
+
+        with col1:
+            flag = "🇰🇷" if stock['market'] == 'krx' else "🇺🇸"
+            st.markdown(f"**{flag} {stock['company_name']}** ({stock['symbol']})")
+            if stock.get('notes'):
+                st.caption(stock['notes'])
+
+        with col2:
+            current_price = stock_service.get_current_price(stock['symbol'])
+            if current_price:
+                st.metric("현재가", f"{current_price:,.0f}")
+
+        with col3:
+            if stock.get('target_price'):
+                st.metric("목표가", f"{stock['target_price']:,.0f}")
+                if current_price:
+                    gap = ((stock['target_price'] - current_price) / current_price) * 100
+                    st.caption(f"Gap: {gap:+.1f}%")
+
+        with col4:
+            if st.button("삭제", key=f"del_watch_{stock['symbol']}"):
+                portfolio_service.remove_from_watchlist(stock['symbol'])
+                st.rerun()
+
+        st.markdown("---")
+
+
+def render_popular_stocks(stock_service: StockService, portfolio_service: PortfolioService):
+    """인기 종목 표시"""
+    tab_kr, tab_us = st.tabs(["🇰🇷 한국", "🇺🇸 미국"])
+
+    with tab_kr:
+        cols = st.columns(4)
+        for i, stock in enumerate(POPULAR_STOCKS["한국"]):
+            with cols[i % 4]:
+                if st.button(f"{stock['name']}\n({stock['symbol']})",
+                            key=f"pop_kr_{stock['symbol']}",
+                            use_container_width=True):
+                    st.session_state.search_symbol = stock['symbol']
+                    st.rerun()
+
+    with tab_us:
+        cols = st.columns(4)
+        for i, stock in enumerate(POPULAR_STOCKS["미국"]):
+            with cols[i % 4]:
+                if st.button(f"{stock['name']}\n({stock['symbol']})",
+                            key=f"pop_us_{stock['symbol']}",
+                            use_container_width=True):
+                    st.session_state.search_symbol = stock['symbol']
+                    st.rerun()
+
+
+def render_search_results(results: list, stock_service: StockService, portfolio_service: PortfolioService):
+    """검색 결과 목록 표시"""
+    for stock in results:
+        col1, col2, col3 = st.columns([3, 1, 1])
+
+        with col1:
+            st.markdown(f"**{stock['name']}** ({stock['symbol']})")
+            st.caption(stock['market'])
+
+        with col2:
+            if st.button("상세보기", key=f"view_{stock['symbol']}"):
+                st.session_state.search_symbol = stock['symbol']
+                st.rerun()
+
+        with col3:
+            if st.button("➕ 추가", key=f"add_{stock['symbol']}"):
+                st.session_state.quick_add_symbol = stock['symbol']
+                st.session_state.quick_add_name = stock['name']
+                st.rerun()
+
+        st.markdown("---")
+
+
+def main():
+    username = check_auth()
+
+    # 사이드바
+    with st.sidebar:
+        st.markdown(f"### 👤 {username}님")
+        st.markdown("---")
+        if st.button("🚪 로그아웃", type="secondary"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+
+    # 서비스 초기화
+    portfolio_service = PortfolioService(username)
+    stock_service = StockService()
+
+    # 헤더
+    st.markdown("# 🔍 종목 탐색")
+
+    # 두 가지 검색 방식
+    tab_name, tab_code = st.tabs(["📝 종목명 검색", "🔢 종목코드 검색"])
+
+    with tab_name:
+        st.caption("종목 이름으로 검색 (KOSPI/KOSDAQ 전체)")
+        with st.form("search_form"):
+            col1, col2, col3 = st.columns([3, 1, 1])
+            with col1:
+                query = st.text_input(
+                    "종목명",
+                    placeholder="예: 삼성전자, SK하이닉스, 카카오..."
+                )
+            with col2:
+                market_filter = st.selectbox("시장", ["전체", "한국", "미국"])
+            with col3:
+                st.markdown("<br>", unsafe_allow_html=True)
+                search_submitted = st.form_submit_button("🔍 검색", type="primary")
+
+        if search_submitted and query:
+            st.session_state.last_query = query
+            st.session_state.last_market = market_filter
+            st.session_state.code_result = None
+
+        if 'last_query' in st.session_state and st.session_state.last_query:
+            market_map = {"전체": "all", "한국": "kr", "미국": "us"}
+            with st.spinner("검색 중..."):
+                results = stock_service.search_stocks(
+                    st.session_state.last_query,
+                    market_map[st.session_state.get('last_market', '전체')]
+                )
+            if results:
+                st.markdown(f"**{len(results)}개 종목 발견**")
+                render_search_results(results, stock_service, portfolio_service)
+            else:
+                st.info("검색 결과가 없습니다. 종목코드 검색을 이용해보세요.")
+
+    with tab_code:
+        st.caption("6자리 종목코드 직접 입력 (모든 상장종목 조회 가능)")
+        with st.form("code_search_form"):
+            col1, col2 = st.columns([2, 1])
+            with col1:
+                code_input = st.text_input(
+                    "종목코드 (6자리)",
+                    placeholder="예: 005930, 000660, 035420..."
+                )
+            with col2:
+                st.markdown("<br>", unsafe_allow_html=True)
+                code_search = st.form_submit_button("🔍 조회", type="primary")
+
+        if code_search and code_input:
+            code_input = code_input.strip().zfill(6)
+            with st.spinner("조회 중..."):
+                result = stock_service.search_by_code(code_input)
+            if result:
+                st.session_state.code_result = result
+                st.session_state.last_query = None
+            else:
+                st.error(f"종목코드 '{code_input}'을 찾을 수 없습니다.")
+                st.session_state.code_result = None
+
+        if 'code_result' in st.session_state and st.session_state.code_result:
+            result = st.session_state.code_result
+            st.success(f"✅ **{result['name']}** ({result['symbol']}) - {result['market']}")
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("📊 상세보기", key="code_view"):
+                    st.session_state.search_symbol = result['symbol']
+                    st.rerun()
+            with col2:
+                if st.button("➕ 포트폴리오 추가", key="code_add"):
+                    st.session_state.quick_add_symbol = result['symbol']
+                    st.session_state.quick_add_name = result['name']
+                    st.rerun()
+
+    # 빠른 추가 모달
+    if 'quick_add_symbol' in st.session_state and st.session_state.quick_add_symbol:
+        symbol = st.session_state.quick_add_symbol
+        name = st.session_state.get('quick_add_name', symbol)
+
+        st.markdown("---")
+        st.markdown(f"### 💼 {name} 포트폴리오에 추가")
+
+        with st.form("quick_add_form_modal"):
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                buy_price = st.number_input("매수 단가", min_value=0.0, step=100.0)
+            with col2:
+                quantity = st.number_input("수량", min_value=1, value=1)
+            with col3:
+                buy_date = st.date_input("매수일", datetime.now())
+
+            col_submit, col_cancel = st.columns(2)
+            with col_submit:
+                if st.form_submit_button("추가", type="primary"):
+                    market = "krx" if stock_service.is_korean_stock(symbol) else "us"
+                    portfolio_service.add_holding(
+                        symbol=symbol,
+                        company_name=name,
+                        market=market,
+                        buy_price=buy_price,
+                        quantity=quantity,
+                        buy_date=buy_date.strftime("%Y-%m-%d")
+                    )
+                    st.success(f"✅ {name} 추가 완료!")
+                    st.session_state.quick_add_symbol = None
+                    st.rerun()
+
+        if st.button("취소"):
+            st.session_state.quick_add_symbol = None
+            st.rerun()
+
+    # 선택된 종목 상세보기
+    if 'search_symbol' in st.session_state and st.session_state.search_symbol:
+        st.markdown("---")
+        st.markdown("### 📊 종목 상세 정보")
+        if st.button("❌ 닫기", key="close_detail"):
+            st.session_state.search_symbol = None
+            st.rerun()
+        render_search_result(st.session_state.search_symbol, stock_service, portfolio_service)
+
+    st.markdown("---")
+
+    # 인기 종목
+    st.markdown("### 📈 인기 종목")
+    render_popular_stocks(stock_service, portfolio_service)
+
+    st.markdown("---")
+
+    # 관심종목
+    st.markdown("### ⭐ 나의 관심종목")
+    render_watchlist(portfolio_service, stock_service)
+
+
+if __name__ == "__main__":
+    main()

pages/4_분석리포트.py

@@ -0,0 +1,223 @@
+"""
+분석 리포트 - AI 분석 히스토리 조회
+"""
+import streamlit as st
+import sys
+import os
+from datetime import datetime
+import pandas as pd
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.analysis_service import AnalysisService
+from services.portfolio_service import PortfolioService
+
+st.set_page_config(page_title="분석 리포트 - TradingAgents", page_icon="📊", layout="wide")
+
+# 공통 CSS - app 메뉴 숨김 및 사이드바 스타일
+st.markdown("""
+<style>
+    [data-testid="stSidebarNav"] span {
+        font-size: 1.1rem !important;
+        font-weight: 500 !important;
+    }
+    [data-testid="stSidebarNav"] > ul > li:first-child {
+        display: none;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def check_auth():
+    if 'authenticated' not in st.session_state or not st.session_state.authenticated:
+        st.warning("로그인이 필요합니다")
+        st.stop()
+    return st.session_state.username
+
+
+def render_report_list(reports: list, analysis_service: AnalysisService):
+    """리포트 목록 렌더링"""
+    if not reports:
+        st.info("아직 분석 리포트가 없습니다. '나의 주식' 메뉴에서 AI 분석을 실행해보세요!")
+        return
+
+    # 테이블 형태로 표시
+    data = []
+    for r in reports:
+        decision = r.get('decision', {})
+        action = decision.get('action', 'N/A') if isinstance(decision, dict) else 'N/A'
+        confidence = decision.get('confidence', 0) if isinstance(decision, dict) else 0
+
+        action_emoji = {
+            'BUY': '🟢', 'STRONG_BUY': '🟢',
+            'SELL': '🔴', 'STRONG_SELL': '🔴',
+            'HOLD': '🟡'
+        }.get(action.upper(), '⚪')
+
+        data.append({
+            "분석일": r.get('analysis_date', ''),
+            "종목": f"{r.get('company_name', '')} ({r.get('symbol', '')})",
+            "시장": "🇰🇷" if r.get('market') == 'krx' else "🇺🇸",
+            "의견": f"{action_emoji} {action}",
+            "신뢰도": f"{confidence}%",
+            "생성일": r.get('created_at', '')[:10],
+            "report_id": r.get('report_id', ''),
+            "symbol": r.get('symbol', '')
+        })
+
+    df = pd.DataFrame(data)
+
+    # 테이블 표시
+    st.dataframe(
+        df[["분석일", "종목", "시장", "의견", "신뢰도", "생성일"]],
+        use_container_width=True,
+        hide_index=True
+    )
+
+    return data
+
+
+def render_report_detail(report: dict):
+    """리포트 상세 보기"""
+    if not report:
+        return
+
+    st.markdown(f"## 📋 {report.get('company_name', '')} ({report.get('symbol', '')})")
+    st.markdown(f"**분석일**: {report.get('analysis_date', '')} | **생성일**: {report.get('created_at', '')[:19]}")
+
+    st.markdown("---")
+
+    # 결정
+    decision = report.get('decision', {})
+    if isinstance(decision, dict):
+        col1, col2 = st.columns(2)
+        with col1:
+            action = decision.get('action', 'N/A')
+            action_korean = {
+                'BUY': '매수', 'STRONG_BUY': '적극 매수',
+                'SELL': '매도', 'STRONG_SELL': '적극 매도',
+                'HOLD': '보유 유지'
+            }.get(action.upper(), action)
+            st.markdown(f"### 투자 의견: {action_korean}")
+        with col2:
+            st.metric("신뢰도", f"{decision.get('confidence', 0)}%")
+
+        if decision.get('reasoning'):
+            st.markdown("### 분석 근거")
+            st.write(decision.get('reasoning'))
+
+    st.markdown("---")
+
+    # 요약 보고서
+    summary = report.get('summary', {})
+    if summary:
+        tabs = st.tabs(["📈 시장 분석", "📰 뉴스", "💬 센티먼트", "📊 펀더멘탈", "📝 투자 계획"])
+
+        with tabs[0]:
+            st.markdown(summary.get('market_report', '정보 없음'))
+
+        with tabs[1]:
+            st.markdown(summary.get('news_report', '정보 없음'))
+
+        with tabs[2]:
+            st.markdown(summary.get('sentiment_report', '정보 없음'))
+
+        with tabs[3]:
+            st.markdown(summary.get('fundamentals_report', '정보 없음'))
+
+        with tabs[4]:
+            st.markdown(summary.get('investment_plan', '정보 없음'))
+            st.markdown("---")
+            st.markdown("**최종 거래 결정**")
+            st.markdown(summary.get('final_trade_decision', '정보 없음'))
+
+    # 전체 상태 (접힌 상태)
+    full_state = report.get('full_state')
+    if full_state:
+        with st.expander("🔍 전체 분석 데이터 (JSON)"):
+            st.json(full_state)
+
+
+def main():
+    username = check_auth()
+
+    # 사이드바
+    with st.sidebar:
+        st.markdown(f"### 👤 {username}님")
+        st.markdown("---")
+        if st.button("🚪 로그아웃", type="secondary"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+
+    # 서비스 초기화
+    analysis_service = AnalysisService(username)
+    portfolio_service = PortfolioService(username)
+
+    # 헤더
+    st.markdown("# 📊 분석 리포트")
+
+    # 통계
+    stats = analysis_service.get_report_statistics()
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("총 분석 수", stats.get('total_reports', 0))
+    with col2:
+        st.metric("분석 종목 수", stats.get('symbols_analyzed', 0))
+    with col3:
+        dist = stats.get('decision_distribution', {})
+        most_common = max(dist.items(), key=lambda x: x[1])[0] if dist else 'N/A'
+        st.metric("주요 의견", most_common)
+
+    st.markdown("---")
+
+    # 필터
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        holdings = portfolio_service.get_all_holdings()
+        symbol_options = ["전체"] + [f"{h['company_name']} ({h['symbol']})" for h in holdings]
+        selected_filter = st.selectbox("종목 필터", symbol_options)
+
+    # 종목 필터 적용
+    if selected_filter == "전체":
+        reports = analysis_service.get_reports(limit=50)
+    else:
+        symbol = selected_filter.split("(")[-1].replace(")", "")
+        reports = analysis_service.get_reports(symbol=symbol, limit=50)
+
+    st.markdown("---")
+
+    # 리포트 목록
+    st.markdown("### 📚 분석 리포트 목록")
+    report_data = render_report_list(reports, analysis_service)
+
+    if report_data:
+        st.markdown("---")
+
+        # 리포트 상세 보기
+        st.markdown("### 📋 리포트 상세 보기")
+
+        report_options = {
+            f"{r['분석일']} - {r['종목']} ({r['의견']})": (r['symbol'], r['report_id'])
+            for r in report_data
+        }
+
+        selected_report = st.selectbox("리포트 선택", list(report_options.keys()))
+
+        if selected_report:
+            symbol, report_id = report_options[selected_report]
+            full_report = analysis_service.get_report(symbol, report_id)
+            render_report_detail(full_report)
+
+            # 삭제 버튼
+            st.markdown("---")
+            col1, col2, col3 = st.columns([1, 1, 2])
+            with col1:
+                if st.button("🗑️ 이 리포트 삭제", type="secondary"):
+                    analysis_service.delete_report(symbol, report_id)
+                    st.success("리포트가 삭제되었습니다")
+                    st.rerun()
+
+
+if __name__ == "__main__":
+    main()

pages/5_설정.py

@@ -0,0 +1,261 @@
+"""
+설정 - 프로필 및 앱 설정
+"""
+import streamlit as st
+import sys
+import os
+import json
+from pathlib import Path
+from datetime import datetime
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.portfolio_service import PortfolioService
+from services.analysis_service import AnalysisService
+
+st.set_page_config(page_title="설정 - TradingAgents", page_icon="⚙️", layout="wide")
+
+# 공통 CSS - app 메뉴 숨김 및 사이드바 스타일
+st.markdown("""
+<style>
+    [data-testid="stSidebarNav"] span {
+        font-size: 1.1rem !important;
+        font-weight: 500 !important;
+    }
+    [data-testid="stSidebarNav"] > ul > li:first-child {
+        display: none;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+def check_auth():
+    if 'authenticated' not in st.session_state or not st.session_state.authenticated:
+        st.warning("로그인이 필요합니다")
+        st.stop()
+    return st.session_state.username
+
+
+def get_data_size(path: Path) -> str:
+    """디렉토리 크기 계산"""
+    total = 0
+    if path.exists():
+        for f in path.rglob('*'):
+            if f.is_file():
+                total += f.stat().st_size
+    if total < 1024:
+        return f"{total} B"
+    elif total < 1024 * 1024:
+        return f"{total / 1024:.1f} KB"
+    else:
+        return f"{total / (1024 * 1024):.1f} MB"
+
+
+def render_profile_section(username: str):
+    """프로필 섹션"""
+    st.markdown("### 👤 프로필")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**사용자 ID**: {username}")
+        st.markdown(f"**가입일**: 2024-01-01")  # 예시
+    with col2:
+        st.markdown(f"**마지막 접속**: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
+
+
+def render_data_section(username: str, portfolio_service: PortfolioService,
+                        analysis_service: AnalysisService):
+    """데이터 관리 섹션"""
+    st.markdown("### 💾 데이터 관리")
+
+    # 데이터 현황
+    holdings = portfolio_service.get_all_holdings()
+    watchlist = portfolio_service.get_watchlist()
+    reports = analysis_service.get_reports(limit=100)
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("보유 종목", f"{len(holdings)}개")
+    with col2:
+        st.metric("관심 종목", f"{len(watchlist)}개")
+    with col3:
+        st.metric("분석 리포트", f"{len(reports)}개")
+
+    # 데이터 크기
+    data_path = Path(__file__).parent.parent / "data" / "users" / username
+    st.info(f"데이터 저장 위치: `{data_path}`")
+    st.info(f"사용 용량: {get_data_size(data_path)}")
+
+    st.markdown("---")
+
+    # 데이터 내보내기
+    st.markdown("#### 📤 데이터 내보내기")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("📋 포트폴리오 내보내기 (JSON)"):
+            portfolio = portfolio_service.load_portfolio()
+            json_str = json.dumps(portfolio, ensure_ascii=False, indent=2)
+            st.download_button(
+                "💾 다운로드",
+                json_str,
+                file_name=f"portfolio_{username}_{datetime.now().strftime('%Y%m%d')}.json",
+                mime="application/json"
+            )
+
+    with col2:
+        if st.button("⭐ 관심종목 내보내기 (JSON)"):
+            watchlist_data = portfolio_service.load_watchlist()
+            json_str = json.dumps(watchlist_data, ensure_ascii=False, indent=2)
+            st.download_button(
+                "💾 다운로드",
+                json_str,
+                file_name=f"watchlist_{username}_{datetime.now().strftime('%Y%m%d')}.json",
+                mime="application/json"
+            )
+
+    st.markdown("---")
+
+    # 데이터 초기화
+    st.markdown("#### ⚠️ 데이터 초기화")
+    st.warning("주의: 데이터 초기화는 되돌릴 수 없습니다!")
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        if st.button("🗑️ 포트폴리오 초기화", type="secondary"):
+            if 'confirm_portfolio_reset' not in st.session_state:
+                st.session_state.confirm_portfolio_reset = True
+                st.rerun()
+
+        if st.session_state.get('confirm_portfolio_reset'):
+            st.error("정말 삭제하시겠습니까?")
+            if st.button("✅ 확인", key="confirm_port"):
+                portfolio_path = data_path / "portfolio.json"
+                if portfolio_path.exists():
+                    portfolio_path.unlink()
+                st.session_state.confirm_portfolio_reset = False
+                st.success("포트폴리오가 초기화되었습니다")
+                st.rerun()
+            if st.button("❌ 취소", key="cancel_port"):
+                st.session_state.confirm_portfolio_reset = False
+                st.rerun()
+
+    with col2:
+        if st.button("🗑️ 관심종목 초기화", type="secondary"):
+            watchlist_path = data_path / "watchlist.json"
+            if watchlist_path.exists():
+                watchlist_path.unlink()
+            st.success("관심종목이 초기화되었습니다")
+            st.rerun()
+
+    with col3:
+        if st.button("🗑️ 분석 리포트 초기화", type="secondary"):
+            reports_path = data_path / "reports"
+            if reports_path.exists():
+                import shutil
+                shutil.rmtree(reports_path)
+            st.success("분석 리포트가 초기화되었습니다")
+            st.rerun()
+
+
+def render_api_section():
+    """API 설정 섹션"""
+    st.markdown("### 🔑 API 설정")
+
+    st.info("AI 분석에 사용되는 API 키는 `.env` 파일에서 관리됩니다.")
+
+    env_path = Path(__file__).parent.parent / ".env"
+    env_example_path = Path(__file__).parent.parent / ".env.example"
+
+    if env_path.exists():
+        st.success("✅ `.env` 파일이 설정되어 있습니다")
+    else:
+        st.warning("⚠️ `.env` 파일이 없습니다. `.env.example`을 참고하여 생성해주세요")
+
+    st.markdown("""
+    **필요한 API 키:**
+    - `OPENAI_API_KEY`: OpenAI API 키 (필수)
+    - `ALPHA_VANTAGE_API_KEY`: Alpha Vantage API 키 (선택)
+    - `FINNHUB_API_KEY`: Finnhub API 키 (선택)
+    """)
+
+
+def render_about_section():
+    """앱 정보 섹션"""
+    st.markdown("### ℹ️ 앱 정보")
+
+    st.markdown("""
+    **TradingAgents** - AI 기반 주식 분석 시스템
+
+    | 항목 | 정보 |
+    |------|------|
+    | 버전 | 1.0.0 |
+    | 프레임워크 | Streamlit |
+    | AI 엔진 | LangGraph + OpenAI |
+    | 데이터 소스 | Yahoo Finance, pykrx |
+
+    ---
+
+    **지원 기능:**
+    - 🇰🇷 한국 주식 (KOSPI, KOSDAQ)
+    - 🇺🇸 미국 주식 (NYSE, NASDAQ)
+    - 🤖 AI 멀티 에이전트 분석
+    - 📊 기술적 지표 분석
+    - 📰 뉴스 & 센티먼트 분석
+
+    ---
+
+    **면책 조항:**
+
+    ⚠️ 본 시스템은 **교육 및 연구 목적**으로만 사용됩니다.
+    - 투자 조언이 아닙니다
+    - 실제 투자 결정에 사용하지 마세요
+    - 과거 성과가 미래 수익을 보장하지 않습니다
+    - AI 분석 결과는 실행할 때마다 다를 수 있습니다
+
+    ---
+
+    **크레딧:**
+    - [TradingAgents](https://github.com/TauricResearch/TradingAgents) by Tauric Research
+    """)
+
+
+def main():
+    username = check_auth()
+
+    # 사이드바
+    with st.sidebar:
+        st.markdown(f"### 👤 {username}님")
+        st.markdown("---")
+        if st.button("🚪 로그아웃", type="secondary"):
+            st.session_state.authenticated = False
+            st.session_state.username = None
+            st.rerun()
+
+    # 서비스 초기화
+    portfolio_service = PortfolioService(username)
+    analysis_service = AnalysisService(username)
+
+    # 헤더
+    st.markdown("# ⚙️ 설정")
+
+    # 탭
+    tab1, tab2, tab3, tab4 = st.tabs(["👤 프로필", "💾 데이터", "🔑 API", "ℹ️ 정보"])
+
+    with tab1:
+        render_profile_section(username)
+
+    with tab2:
+        render_data_section(username, portfolio_service, analysis_service)
+
+    with tab3:
+        render_api_section()
+
+    with tab4:
+        render_about_section()
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,38 @@
+typing-extensions
+python-dotenv
+langchain-openai
+tenacity
+beautifulsoup4
+langchain-experimental
+pandas
+plotly
+streamlit
+yfinance
+praw
+feedparser
+stockstats
+eodhd
+langgraph
+chromadb
+setuptools
+backtrader
+akshare
+tushare
+finnhub-python
+parsel
+requests
+tqdm
+pytz
+redis
+chainlit
+rich
+questionary
+langchain_anthropic
+langchain-google-genai
+# 한국 주식 데이터 라이브러리
+pykrx
+finance-datareader
+
+# 딥러닝 시계열 예측
+neuralforecast
+scipy

services/__init__.py

@@ -0,0 +1,8 @@
+"""
+TradingAgents 서비스 모듈
+"""
+from .portfolio_service import PortfolioService
+from .stock_service import StockService
+from .analysis_service import AnalysisService
+
+__all__ = ['PortfolioService', 'StockService', 'AnalysisService']

services/analysis_service.py

@@ -0,0 +1,300 @@
+"""
+AI 분석 서비스
+TradingAgents AI 분석 실행 및 리포트 관리
+"""
+import json
+import os
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Optional, List, Tuple
+import uuid
+
+# .env 파일 로드
+from dotenv import load_dotenv
+load_dotenv()
+
+
+class AnalysisService:
+    """AI 분석 및 리포트 관리 서비스"""
+
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self.reports_path = Path(__file__).parent.parent / "data" / "users" / user_id / "reports"
+        self._ensure_reports_directory()
+
+    def _ensure_reports_directory(self):
+        """리포트 디렉토리 생성"""
+        self.reports_path.mkdir(parents=True, exist_ok=True)
+
+    def run_analysis(self, symbol: str, analysis_date: str,
+                     progress_callback=None) -> Tuple[Optional[Dict], Optional[str]]:
+        """
+        AI 분석 실행
+
+        Args:
+            symbol: 종목 코드/티커
+            analysis_date: 분석 기준일 (YYYY-MM-DD)
+            progress_callback: 진행 상황 콜백 함수
+
+        Returns:
+            (decision_dict, error_message)
+        """
+        try:
+            from tradingagents.graph.trading_graph import TradingAgentsGraph
+            from tradingagents.default_config import DEFAULT_CONFIG
+
+            config = DEFAULT_CONFIG.copy()
+            ta = TradingAgentsGraph(debug=False, config=config)
+
+            if progress_callback:
+                progress_callback("AI 에이전트 초기화 완료")
+
+            # 분석 실행
+            final_state, decision = ta.propagate(symbol, analysis_date)
+
+            if progress_callback:
+                progress_callback("분석 완료")
+
+            # decision을 상세 딕셔너리로 변환
+            decision_dict = self._build_decision_dict(decision, final_state)
+
+            # 리포트 저장
+            report = self._create_report(symbol, analysis_date, final_state, decision_dict)
+            self.save_report(report)
+
+            return decision_dict, None
+
+        except Exception as e:
+            return None, str(e)
+
+    def _build_decision_dict(self, decision, final_state: Dict) -> Dict:
+        """단순 결정을 상세 딕셔너리로 변환"""
+        # decision이 이미 딕셔너리면 그대로 반환
+        if isinstance(decision, dict):
+            return decision
+
+        # 문자열인 경우 상세 정보 구성
+        action = decision.upper() if isinstance(decision, str) else "HOLD"
+
+        # final_state에서 근거 추출
+        reasoning_parts = []
+
+        # 최종 거래 결정에서 근거 추출
+        final_decision = final_state.get("final_trade_decision", "")
+        if final_decision:
+            reasoning_parts.append(f"**최종 판단:**\n{final_decision[:500]}")
+
+        # 투자 계획에서 근거 추출
+        investment_plan = final_state.get("investment_plan", "")
+        if investment_plan:
+            reasoning_parts.append(f"**투자 계획:**\n{investment_plan[:500]}")
+
+        # 각 분석 리포트 요약
+        reports = []
+        if final_state.get("market_report"):
+            reports.append(f"📈 시장분석: {final_state['market_report'][:200]}...")
+        if final_state.get("news_report"):
+            reports.append(f"📰 뉴스분석: {final_state['news_report'][:200]}...")
+        if final_state.get("fundamentals_report"):
+            reports.append(f"📊 펀더멘탈: {final_state['fundamentals_report'][:200]}...")
+        if final_state.get("sentiment_report"):
+            reports.append(f"💬 센티먼트: {final_state['sentiment_report'][:200]}...")
+
+        if reports:
+            reasoning_parts.append("**분석 요약:**\n" + "\n".join(reports))
+
+        reasoning = "\n\n".join(reasoning_parts) if reasoning_parts else "상세 분석 정보 없음"
+
+        # 신뢰도 계산 (분석 리포트 수에 따라)
+        report_count = sum(1 for k in ["market_report", "news_report", "fundamentals_report", "sentiment_report"]
+                          if final_state.get(k))
+        confidence = min(report_count * 20 + 20, 80)  # 20~80%
+
+        return {
+            "action": action,
+            "confidence": confidence,
+            "reasoning": reasoning
+        }
+
+    def _create_report(self, symbol: str, analysis_date: str,
+                       final_state: Dict, decision: Dict) -> Dict:
+        """분석 결과로 리포트 생성"""
+        from services.stock_service import StockService
+        stock_service = StockService()
+        company_name, market = stock_service.get_company_info(symbol)
+
+        return {
+            "report_id": str(uuid.uuid4()),
+            "user_id": self.user_id,
+            "symbol": symbol,
+            "company_name": company_name,
+            "market": "krx" if StockService.is_korean_stock(symbol) else "us",
+            "analysis_date": analysis_date,
+            "created_at": datetime.now().isoformat(),
+            "decision": decision,
+            "summary": self._extract_summary(final_state),
+            "full_state": final_state
+        }
+
+    def _extract_summary(self, final_state: Dict) -> Dict:
+        """전체 상태에서 요약 정보 추출"""
+        if not final_state:
+            return {}
+
+        return {
+            "market_report": final_state.get("market_report", ""),
+            "sentiment_report": final_state.get("sentiment_report", ""),
+            "news_report": final_state.get("news_report", ""),
+            "fundamentals_report": final_state.get("fundamentals_report", ""),
+            "investment_plan": final_state.get("investment_plan", ""),
+            "final_trade_decision": final_state.get("final_trade_decision", "")
+        }
+
+    def save_report(self, report: Dict) -> str:
+        """리포트 저장"""
+        symbol = report["symbol"]
+        report_id = report["report_id"]
+        analysis_date = report["analysis_date"]
+
+        # 종목별 디렉토리 생성
+        symbol_path = self.reports_path / symbol
+        symbol_path.mkdir(exist_ok=True)
+
+        # 파일명: {날짜}_{report_id}.json
+        filename = f"{analysis_date}_{report_id[:8]}.json"
+        file_path = symbol_path / filename
+
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(report, f, ensure_ascii=False, indent=2, default=str)
+
+        return str(file_path)
+
+    def get_reports(self, symbol: str = None, limit: int = 20) -> List[Dict]:
+        """리포트 목록 조회"""
+        reports = []
+
+        if symbol:
+            # 특정 종목 리포트
+            symbol_path = self.reports_path / symbol
+            if symbol_path.exists():
+                for file_path in sorted(symbol_path.glob("*.json"), reverse=True)[:limit]:
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            report = json.load(f)
+                            # 전체 상태는 목록에서 제외 (크기 줄이기)
+                            report.pop("full_state", None)
+                            reports.append(report)
+                    except:
+                        pass
+        else:
+            # 전체 리포트
+            for symbol_dir in self.reports_path.iterdir():
+                if symbol_dir.is_dir():
+                    for file_path in symbol_dir.glob("*.json"):
+                        try:
+                            with open(file_path, 'r', encoding='utf-8') as f:
+                                report = json.load(f)
+                                report.pop("full_state", None)
+                                reports.append(report)
+                        except:
+                            pass
+
+            # 날짜순 정렬
+            reports.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+            reports = reports[:limit]
+
+        return reports
+
+    def get_report(self, symbol: str, report_id: str) -> Optional[Dict]:
+        """특정 리포트 상세 조회"""
+        symbol_path = self.reports_path / symbol
+
+        if not symbol_path.exists():
+            return None
+
+        for file_path in symbol_path.glob(f"*_{report_id[:8]}.json"):
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except:
+                pass
+
+        return None
+
+    def delete_report(self, symbol: str, report_id: str) -> bool:
+        """리포트 삭제"""
+        symbol_path = self.reports_path / symbol
+
+        if not symbol_path.exists():
+            return False
+
+        for file_path in symbol_path.glob(f"*_{report_id[:8]}.json"):
+            try:
+                file_path.unlink()
+                return True
+            except:
+                pass
+
+        return False
+
+    def get_latest_report(self, symbol: str) -> Optional[Dict]:
+        """특정 종목의 최신 리포트 조회"""
+        reports = self.get_reports(symbol=symbol, limit=1)
+        return reports[0] if reports else None
+
+    def format_decision_korean(self, decision) -> str:
+        """결정 정보를 한국어로 포맷팅"""
+        if not decision:
+            return "분석 결과 없음"
+
+        # decision이 문자열인 경우 처리
+        if isinstance(decision, str):
+            action = decision
+            confidence = 0
+            reasoning = ""
+        else:
+            action = decision.get("action", "HOLD")
+            confidence = decision.get("confidence", 0)
+            reasoning = decision.get("reasoning", "")
+
+        action_korean = {
+            "BUY": "매수",
+            "SELL": "매도",
+            "HOLD": "보유 유지",
+            "STRONG_BUY": "적극 매수",
+            "STRONG_SELL": "적극 매도"
+        }.get(action.upper(), action)
+
+        return f"""
+## 투자 의견: {action_korean}
+
+**신뢰도**: {confidence}%
+
+### 분석 근거
+{reasoning}
+"""
+
+    def get_report_statistics(self) -> Dict:
+        """리포트 통계 조회"""
+        reports = self.get_reports(limit=100)
+
+        if not reports:
+            return {
+                "total_reports": 0,
+                "symbols_analyzed": 0,
+                "decision_distribution": {}
+            }
+
+        symbols = set(r.get("symbol") for r in reports)
+        decisions = {}
+        for r in reports:
+            decision = r.get("decision", {})
+            action = decision.get("action", "UNKNOWN") if isinstance(decision, dict) else "UNKNOWN"
+            decisions[action] = decisions.get(action, 0) + 1
+
+        return {
+            "total_reports": len(reports),
+            "symbols_analyzed": len(symbols),
+            "decision_distribution": decisions,
+            "recent_reports": reports[:5]
+        }

services/portfolio_service.py

@@ -0,0 +1,246 @@
+"""
+포트폴리오 관리 서비스
+사용자별 포트폴리오 데이터를 JSON 파일로 관리
+"""
+import json
+import os
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional
+import uuid
+
+
+class PortfolioService:
+    """포트폴리오 CRUD 서비스"""
+
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self.base_path = Path(__file__).parent.parent / "data" / "users" / user_id
+        self.portfolio_path = self.base_path / "portfolio.json"
+        self.watchlist_path = self.base_path / "watchlist.json"
+        self._ensure_user_directory()
+
+    def _ensure_user_directory(self):
+        """사용자 디렉토리가 없으면 생성"""
+        self.base_path.mkdir(parents=True, exist_ok=True)
+
+    def _get_empty_portfolio(self) -> Dict:
+        """빈 포트폴리오 구조 반환"""
+        return {
+            "user_id": self.user_id,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "holdings": []
+        }
+
+    def _get_empty_watchlist(self) -> Dict:
+        """빈 관심종목 구조 반환"""
+        return {
+            "user_id": self.user_id,
+            "updated_at": datetime.now().isoformat(),
+            "stocks": []
+        }
+
+    # ==================== 포트폴리오 CRUD ====================
+
+    def load_portfolio(self) -> Dict:
+        """포트폴리오 로드"""
+        if self.portfolio_path.exists():
+            with open(self.portfolio_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return self._get_empty_portfolio()
+
+    def save_portfolio(self, portfolio: Dict):
+        """포트폴리오 저장"""
+        portfolio["updated_at"] = datetime.now().isoformat()
+        with open(self.portfolio_path, 'w', encoding='utf-8') as f:
+            json.dump(portfolio, f, ensure_ascii=False, indent=2)
+
+    def add_holding(self, symbol: str, company_name: str, market: str,
+                    buy_price: float, quantity: int, buy_date: str,
+                    memo: str = "") -> Dict:
+        """종목 추가 또는 추가 매수"""
+        portfolio = self.load_portfolio()
+
+        # 기존 보유 종목인지 확인
+        existing = next(
+            (h for h in portfolio["holdings"] if h["symbol"] == symbol),
+            None
+        )
+
+        if existing:
+            # 추가 매수: 평균 단가 재계산
+            total_cost = (existing["buy_price"] * existing["quantity"]) + (buy_price * quantity)
+            total_qty = existing["quantity"] + quantity
+            existing["buy_price"] = round(total_cost / total_qty, 2)
+            existing["quantity"] = total_qty
+            existing["memo"] = memo if memo else existing.get("memo", "")
+            holding = existing
+        else:
+            # 새 종목 추가
+            holding = {
+                "id": str(uuid.uuid4()),
+                "symbol": symbol,
+                "company_name": company_name,
+                "market": market,  # "krx" or "us"
+                "buy_price": buy_price,
+                "quantity": quantity,
+                "buy_date": buy_date,
+                "memo": memo
+            }
+            portfolio["holdings"].append(holding)
+
+        self.save_portfolio(portfolio)
+        return holding
+
+    def update_holding(self, symbol: str, buy_price: float = None,
+                       quantity: int = None, memo: str = None) -> Optional[Dict]:
+        """보유 종목 수정"""
+        portfolio = self.load_portfolio()
+
+        for holding in portfolio["holdings"]:
+            if holding["symbol"] == symbol:
+                if buy_price is not None:
+                    holding["buy_price"] = buy_price
+                if quantity is not None:
+                    holding["quantity"] = quantity
+                if memo is not None:
+                    holding["memo"] = memo
+                self.save_portfolio(portfolio)
+                return holding
+
+        return None
+
+    def remove_holding(self, symbol: str) -> bool:
+        """보유 종목 삭제"""
+        portfolio = self.load_portfolio()
+        original_len = len(portfolio["holdings"])
+        portfolio["holdings"] = [
+            h for h in portfolio["holdings"] if h["symbol"] != symbol
+        ]
+
+        if len(portfolio["holdings"]) < original_len:
+            self.save_portfolio(portfolio)
+            return True
+        return False
+
+    def get_holding(self, symbol: str) -> Optional[Dict]:
+        """특정 보유 종목 조회"""
+        portfolio = self.load_portfolio()
+        return next(
+            (h for h in portfolio["holdings"] if h["symbol"] == symbol),
+            None
+        )
+
+    def get_all_holdings(self) -> List[Dict]:
+        """전체 보유 종목 조회"""
+        portfolio = self.load_portfolio()
+        return portfolio.get("holdings", [])
+
+    # ==================== 관심종목 CRUD ====================
+
+    def load_watchlist(self) -> Dict:
+        """관심종목 로드"""
+        if self.watchlist_path.exists():
+            with open(self.watchlist_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return self._get_empty_watchlist()
+
+    def save_watchlist(self, watchlist: Dict):
+        """관심종목 저장"""
+        watchlist["updated_at"] = datetime.now().isoformat()
+        with open(self.watchlist_path, 'w', encoding='utf-8') as f:
+            json.dump(watchlist, f, ensure_ascii=False, indent=2)
+
+    def add_to_watchlist(self, symbol: str, company_name: str, market: str,
+                         target_price: float = None, notes: str = "") -> Dict:
+        """관심종목 추가"""
+        watchlist = self.load_watchlist()
+
+        # 이미 있는지 확인
+        if any(s["symbol"] == symbol for s in watchlist["stocks"]):
+            return None
+
+        stock = {
+            "symbol": symbol,
+            "company_name": company_name,
+            "market": market,
+            "added_at": datetime.now().isoformat(),
+            "target_price": target_price,
+            "notes": notes
+        }
+        watchlist["stocks"].append(stock)
+        self.save_watchlist(watchlist)
+        return stock
+
+    def remove_from_watchlist(self, symbol: str) -> bool:
+        """관심종목 삭제"""
+        watchlist = self.load_watchlist()
+        original_len = len(watchlist["stocks"])
+        watchlist["stocks"] = [
+            s for s in watchlist["stocks"] if s["symbol"] != symbol
+        ]
+
+        if len(watchlist["stocks"]) < original_len:
+            self.save_watchlist(watchlist)
+            return True
+        return False
+
+    def get_watchlist(self) -> List[Dict]:
+        """관심종목 목록 조회"""
+        watchlist = self.load_watchlist()
+        return watchlist.get("stocks", [])
+
+    # ==================== 수익률 계산 ====================
+
+    def calculate_profit(self, holding: Dict, current_price: float) -> Dict:
+        """개별 종목 수익률 계산"""
+        invested = holding["buy_price"] * holding["quantity"]
+        current_value = current_price * holding["quantity"]
+        profit = current_value - invested
+        profit_rate = (profit / invested) * 100 if invested > 0 else 0
+
+        return {
+            "symbol": holding["symbol"],
+            "company_name": holding["company_name"],
+            "buy_price": holding["buy_price"],
+            "current_price": current_price,
+            "quantity": holding["quantity"],
+            "invested": invested,
+            "current_value": current_value,
+            "profit": profit,
+            "profit_rate": round(profit_rate, 2)
+        }
+
+    def calculate_portfolio_summary(self, current_prices: Dict[str, float]) -> Dict:
+        """포트폴리오 전체 요약 계산"""
+        holdings = self.get_all_holdings()
+
+        if not holdings:
+            return {
+                "total_invested": 0,
+                "total_current": 0,
+                "total_profit": 0,
+                "total_profit_rate": 0,
+                "holdings_count": 0
+            }
+
+        total_invested = 0
+        total_current = 0
+
+        for h in holdings:
+            invested = h["buy_price"] * h["quantity"]
+            current = current_prices.get(h["symbol"], h["buy_price"]) * h["quantity"]
+            total_invested += invested
+            total_current += current
+
+        total_profit = total_current - total_invested
+        total_profit_rate = (total_profit / total_invested) * 100 if total_invested > 0 else 0
+
+        return {
+            "total_invested": round(total_invested, 2),
+            "total_current": round(total_current, 2),
+            "total_profit": round(total_profit, 2),
+            "total_profit_rate": round(total_profit_rate, 2),
+            "holdings_count": len(holdings)
+        }

services/stock_service.py

@@ -0,0 +1,641 @@
+"""
+주식 데이터 서비스
+한국/미국 주식 데이터 조회 및 차트 생성
+"""
+from __future__ import annotations
+
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Tuple, Optional, Dict, List, TYPE_CHECKING
+from io import StringIO
+
+if TYPE_CHECKING:
+    import plotly.graph_objects as go
+
+
+class StockService:
+    """주식 데이터 조회 및 차트 생성 서비스"""
+
+    _krx_stock_list = None  # 메모리 캐시
+    _cache_file = None  # 파일 캐시 경로
+
+    # 주요 한국 종목 리스트 (API 실패 시 백업)
+    KRX_POPULAR_STOCKS = [
+        # KOSPI 대형주
+        {"symbol": "005930", "name": "삼성전자", "market": "KOSPI"},
+        {"symbol": "000660", "name": "SK하이닉스", "market": "KOSPI"},
+        {"symbol": "005380", "name": "현대차", "market": "KOSPI"},
+        {"symbol": "000270", "name": "기아", "market": "KOSPI"},
+        {"symbol": "005490", "name": "POSCO홀딩스", "market": "KOSPI"},
+        {"symbol": "035420", "name": "NAVER", "market": "KOSPI"},
+        {"symbol": "035720", "name": "카카오", "market": "KOSPI"},
+        {"symbol": "051910", "name": "LG화학", "market": "KOSPI"},
+        {"symbol": "006400", "name": "삼성SDI", "market": "KOSPI"},
+        {"symbol": "003670", "name": "포스코퓨처엠", "market": "KOSPI"},
+        {"symbol": "068270", "name": "셀트리온", "market": "KOSPI"},
+        {"symbol": "207940", "name": "삼성바이오로직스", "market": "KOSPI"},
+        {"symbol": "005935", "name": "삼성전자우", "market": "KOSPI"},
+        {"symbol": "028260", "name": "삼성물산", "market": "KOSPI"},
+        {"symbol": "012330", "name": "현대모비스", "market": "KOSPI"},
+        {"symbol": "066570", "name": "LG전자", "market": "KOSPI"},
+        {"symbol": "003550", "name": "LG", "market": "KOSPI"},
+        {"symbol": "096770", "name": "SK이노베이션", "market": "KOSPI"},
+        {"symbol": "034730", "name": "SK", "market": "KOSPI"},
+        {"symbol": "015760", "name": "한국전력", "market": "KOSPI"},
+        {"symbol": "017670", "name": "SK텔레콤", "market": "KOSPI"},
+        {"symbol": "030200", "name": "KT", "market": "KOSPI"},
+        {"symbol": "032830", "name": "삼성생명", "market": "KOSPI"},
+        {"symbol": "055550", "name": "신한지주", "market": "KOSPI"},
+        {"symbol": "105560", "name": "KB금융", "market": "KOSPI"},
+        {"symbol": "086790", "name": "하나금융지주", "market": "KOSPI"},
+        {"symbol": "316140", "name": "우리금융지주", "market": "KOSPI"},
+        {"symbol": "009150", "name": "삼성전기", "market": "KOSPI"},
+        {"symbol": "000810", "name": "삼성화재", "market": "KOSPI"},
+        {"symbol": "018260", "name": "삼성에스디에스", "market": "KOSPI"},
+        {"symbol": "033780", "name": "KT&G", "market": "KOSPI"},
+        {"symbol": "010130", "name": "고려아연", "market": "KOSPI"},
+        {"symbol": "090430", "name": "아모레퍼시픽", "market": "KOSPI"},
+        {"symbol": "011170", "name": "롯데케미칼", "market": "KOSPI"},
+        {"symbol": "010950", "name": "S-Oil", "market": "KOSPI"},
+        {"symbol": "036570", "name": "엔씨소프트", "market": "KOSPI"},
+        {"symbol": "251270", "name": "넷마블", "market": "KOSPI"},
+        {"symbol": "352820", "name": "하이브", "market": "KOSPI"},
+        {"symbol": "011780", "name": "금호석유", "market": "KOSPI"},
+        {"symbol": "086280", "name": "현대글로비스", "market": "KOSPI"},
+        # KOSDAQ 주요 종목
+        {"symbol": "247540", "name": "에코프로비엠", "market": "KOSDAQ"},
+        {"symbol": "086520", "name": "에코프로", "market": "KOSDAQ"},
+        {"symbol": "028300", "name": "HLB", "market": "KOSDAQ"},
+        {"symbol": "293490", "name": "카카오게임즈", "market": "KOSDAQ"},
+        {"symbol": "263750", "name": "펄어비스", "market": "KOSDAQ"},
+        {"symbol": "112040", "name": "위메이드", "market": "KOSDAQ"},
+        {"symbol": "041510", "name": "에스엠", "market": "KOSDAQ"},
+        {"symbol": "035900", "name": "JYP Ent.", "market": "KOSDAQ"},
+        {"symbol": "122870", "name": "와이지엔터테인먼트", "market": "KOSDAQ"},
+        {"symbol": "377300", "name": "카카오페이", "market": "KOSDAQ"},
+        {"symbol": "323410", "name": "카카오뱅크", "market": "KOSDAQ"},
+        {"symbol": "145020", "name": "휴젤", "market": "KOSDAQ"},
+        {"symbol": "091990", "name": "셀트리온헬스케어", "market": "KOSDAQ"},
+        {"symbol": "196170", "name": "알테오젠", "market": "KOSDAQ"},
+        {"symbol": "141080", "name": "레고켐바이오", "market": "KOSDAQ"},
+        {"symbol": "095340", "name": "ISC", "market": "KOSDAQ"},
+        {"symbol": "357780", "name": "솔브레인", "market": "KOSDAQ"},
+        {"symbol": "058470", "name": "리노공업", "market": "KOSDAQ"},
+        {"symbol": "140860", "name": "파크시스템스", "market": "KOSDAQ"},
+        {"symbol": "067310", "name": "하나마이크론", "market": "KOSDAQ"},
+    ]
+
+    @classmethod
+    def _get_cache_path(cls):
+        """캐시 파일 경로"""
+        import os
+        cache_dir = os.path.join(os.path.dirname(__file__), '..', 'data', 'cache')
+        os.makedirs(cache_dir, exist_ok=True)
+        return os.path.join(cache_dir, 'krx_stocks.json')
+
+    @classmethod
+    def _load_from_cache(cls) -> Optional[pd.DataFrame]:
+        """로컬 캐시에서 로드 (24시간 유효)"""
+        import os
+        import json
+        cache_path = cls._get_cache_path()
+        if os.path.exists(cache_path):
+            try:
+                mtime = os.path.getmtime(cache_path)
+                age_hours = (datetime.now().timestamp() - mtime) / 3600
+                if age_hours < 24:  # 24시간 이내
+                    with open(cache_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                    if data:
+                        print(f"캐시 로드: {len(data)}개 종목 ({age_hours:.1f}시간 전)")
+                        return pd.DataFrame(data)
+            except Exception as e:
+                print(f"캐시 로드 실패: {e}")
+        return None
+
+    @classmethod
+    def _save_to_cache(cls, df: pd.DataFrame):
+        """로컬 캐시에 저장"""
+        import json
+        try:
+            cache_path = cls._get_cache_path()
+            with open(cache_path, 'w', encoding='utf-8') as f:
+                json.dump(df.to_dict('records'), f, ensure_ascii=False)
+        except Exception as e:
+            print(f"캐시 저장 실패: {e}")
+
+    @classmethod
+    def get_krx_stock_list(cls) -> pd.DataFrame:
+        """한국 주식 전체 종목 리스트 (파일 캐시 → 네이버 API → 폴백)"""
+        if cls._krx_stock_list is not None:
+            return cls._krx_stock_list
+
+        # 1) 파일 캐시 확인 (가장 빠름)
+        stock_list = cls._load_from_cache()
+        if stock_list is not None and not stock_list.empty:
+            cls._krx_stock_list = stock_list
+            return cls._krx_stock_list
+
+        # 2) 네이버 금융 API
+        try:
+            import requests
+            all_stocks = []
+            for mkt in ['KOSPI', 'KOSDAQ']:
+                for page in range(1, 50):
+                    url = f'https://m.stock.naver.com/api/stocks/marketValue/{mkt}?page={page}&pageSize=100'
+                    res = requests.get(url, timeout=10)
+                    if res.status_code != 200:
+                        break
+                    data = res.json()
+                    stocks = data.get('stocks', [])
+                    if not stocks:
+                        break
+                    for s in stocks:
+                        code = s.get('itemCode', '')
+                        name = s.get('stockName', '')
+                        if code and name:
+                            all_stocks.append({"symbol": code, "name": name, "market": mkt})
+            if all_stocks:
+                stock_list = pd.DataFrame(all_stocks)
+                cls._save_to_cache(stock_list)  # 캐시 저장
+                print(f"KRX 종목 로드 완료: {len(all_stocks)}개 (네이버)")
+        except Exception as e:
+            print(f"네이버 API 실패: {e}")
+            stock_list = None
+
+        # 3) pykrx 폴백
+        if stock_list is None or stock_list.empty:
+            try:
+                from pykrx import stock as pykrx_stock
+                tickers_with_market = []
+                for market in ["KOSPI", "KOSDAQ"]:
+                    try:
+                        tickers = pykrx_stock.get_market_ticker_list(market=market)
+                    except:
+                        tickers = []
+                    if tickers:
+                        tickers_with_market.extend((t, market) for t in tickers)
+                if tickers_with_market:
+                    symbols = [t for t, _ in tickers_with_market]
+                    markets = [m for _, m in tickers_with_market]
+                    names = [pykrx_stock.get_market_ticker_name(t) for t in symbols]
+                    stock_list = pd.DataFrame({"symbol": symbols, "name": names, "market": markets})
+                    cls._save_to_cache(stock_list)
+            except:
+                stock_list = None
+
+        # 4) 최종 폴백: 인기 종목 리스트
+        if stock_list is None or stock_list.empty:
+            stock_list = pd.DataFrame(cls.KRX_POPULAR_STOCKS)
+            print(f"백업 리스트 사용: {len(cls.KRX_POPULAR_STOCKS)}개")
+
+        cls._krx_stock_list = stock_list.reset_index(drop=True)
+        return cls._krx_stock_list
+
+    def search_by_code(self, code: str) -> Optional[Dict]:
+        """종목코드로 직접 조회 (6자리)"""
+        if not code or len(code) != 6 or not code.isdigit():
+            return None
+        try:
+            import requests
+            url = f'https://m.stock.naver.com/api/stock/{code}/basic'
+            res = requests.get(url, timeout=5)
+            if res.status_code == 200:
+                data = res.json()
+                name = data.get('stockName', '')
+                exchange = data.get('stockExchangeType', {})
+                market = exchange.get('nameKor', 'KRX') if isinstance(exchange, dict) else 'KRX'
+                if name:
+                    return {"symbol": code, "name": name, "market": f"🇰🇷 {market}"}
+        except:
+            pass
+        return None
+
+    def search_stocks(self, query: str, market: str = "all", limit: int = 20) -> List[Dict]:
+        """
+        종목명/코드로 검색
+
+        Args:
+            query: 검색어 (종목명 또는 코드)
+            market: "kr", "us", "all"
+            limit: 최대 결과 수
+
+        Returns:
+            [{"symbol": "005930", "name": "삼성전자", "market": "KOSPI"}, ...]
+        """
+        results = []
+        query = query.strip()
+
+        if not query:
+            return results
+
+        # 한국 주식 검색
+        if market in ["kr", "all"]:
+            kr_stocks = self.get_krx_stock_list()
+            if not kr_stocks.empty:
+                # 종목명 또는 코드에서 검색 (한글은 대소문자 구분 없음)
+                mask = (
+                    kr_stocks['name'].astype(str).str.contains(query, case=False, regex=False, na=False) |
+                    kr_stocks['symbol'].astype(str).str.contains(query, regex=False, na=False)
+                )
+                kr_limit = limit if market == "kr" else max(1, limit // 2)
+                matches = kr_stocks[mask].head(kr_limit)
+                for _, row in matches.iterrows():
+                    results.append({
+                        "symbol": row['symbol'],
+                        "name": row['name'],
+                        "market": f"🇰🇷 {row['market']}"
+                    })
+
+        # 미국 주식 검색
+        if market in ["us", "all"]:
+            try:
+                import yfinance as yf
+                # yfinance는 직접 검색 API가 없어서 인기 종목에서 매칭
+                us_popular = [
+                    {"symbol": "AAPL", "name": "Apple Inc."},
+                    {"symbol": "MSFT", "name": "Microsoft Corporation"},
+                    {"symbol": "GOOGL", "name": "Alphabet Inc."},
+                    {"symbol": "AMZN", "name": "Amazon.com Inc."},
+                    {"symbol": "NVDA", "name": "NVIDIA Corporation"},
+                    {"symbol": "META", "name": "Meta Platforms Inc."},
+                    {"symbol": "TSLA", "name": "Tesla Inc."},
+                    {"symbol": "AMD", "name": "Advanced Micro Devices"},
+                    {"symbol": "NFLX", "name": "Netflix Inc."},
+                    {"symbol": "INTC", "name": "Intel Corporation"},
+                    {"symbol": "CRM", "name": "Salesforce Inc."},
+                    {"symbol": "ORCL", "name": "Oracle Corporation"},
+                    {"symbol": "CSCO", "name": "Cisco Systems"},
+                    {"symbol": "ADBE", "name": "Adobe Inc."},
+                    {"symbol": "QCOM", "name": "Qualcomm Inc."},
+                    {"symbol": "IBM", "name": "IBM"},
+                    {"symbol": "BA", "name": "Boeing Company"},
+                    {"symbol": "DIS", "name": "Walt Disney Company"},
+                    {"symbol": "JPM", "name": "JPMorgan Chase"},
+                    {"symbol": "V", "name": "Visa Inc."},
+                    {"symbol": "MA", "name": "Mastercard Inc."},
+                    {"symbol": "KO", "name": "Coca-Cola Company"},
+                    {"symbol": "PEP", "name": "PepsiCo Inc."},
+                    {"symbol": "MCD", "name": "McDonald's Corporation"},
+                    {"symbol": "NKE", "name": "Nike Inc."},
+                    {"symbol": "WMT", "name": "Walmart Inc."},
+                    {"symbol": "COST", "name": "Costco Wholesale"},
+                    {"symbol": "HD", "name": "Home Depot"},
+                    {"symbol": "UNH", "name": "UnitedHealth Group"},
+                    {"symbol": "JNJ", "name": "Johnson & Johnson"},
+                    {"symbol": "PFE", "name": "Pfizer Inc."},
+                    {"symbol": "MRNA", "name": "Moderna Inc."},
+                    {"symbol": "BABA", "name": "Alibaba Group"},
+                    {"symbol": "TSM", "name": "Taiwan Semiconductor"},
+                    {"symbol": "ASML", "name": "ASML Holding"},
+                    {"symbol": "AVGO", "name": "Broadcom Inc."},
+                    {"symbol": "TXN", "name": "Texas Instruments"},
+                    {"symbol": "MU", "name": "Micron Technology"},
+                    {"symbol": "PLTR", "name": "Palantir Technologies"},
+                    {"symbol": "SNOW", "name": "Snowflake Inc."},
+                ]
+
+                query_upper = query.upper()
+                for stock in us_popular:
+                    if query_upper in stock['symbol'] or query_upper in stock['name'].upper():
+                        results.append({
+                            "symbol": stock['symbol'],
+                            "name": stock['name'],
+                            "market": "🇺🇸 NASDAQ/NYSE"
+                        })
+                        if len(results) >= limit:
+                            break
+
+                # 직접 티커 조회 시도 (영문만)
+                if len(query) <= 5 and query.isalpha():
+                    try:
+                        ticker = yf.Ticker(query_upper)
+                        info = ticker.info
+                        if info.get('regularMarketPrice'):
+                            # 중복 체크
+                            if not any(r['symbol'] == query_upper for r in results):
+                                results.append({
+                                    "symbol": query_upper,
+                                    "name": info.get('longName', query_upper),
+                                    "market": "🇺🇸 " + info.get('exchange', 'US')
+                                })
+                    except:
+                        pass
+            except Exception as e:
+                print(f"US 종목 검색 실패: {e}")
+
+        return results[:limit]
+
+    @staticmethod
+    def is_korean_stock(symbol: str) -> bool:
+        """한국 주식 여부 판단 (6자리 숫자)"""
+        return symbol.isdigit() and len(symbol) == 6
+
+    @staticmethod
+    def get_market(symbol: str) -> str:
+        """시장 구분 반환"""
+        return "krx" if StockService.is_korean_stock(symbol) else "us"
+
+    def get_stock_data(self, symbol: str, start_date: str, end_date: str) -> Tuple[Optional[pd.DataFrame], Optional[str]]:
+        """
+        종목 유형에 따라 주식 데이터 가져오기
+
+        Args:
+            symbol: 종목 코드/티커
+            start_date: 시작일 (YYYY-MM-DD)
+            end_date: 종료일 (YYYY-MM-DD)
+
+        Returns:
+            (DataFrame, error_message)
+        """
+        from tradingagents.dataflows.krx import is_korean_stock, get_krx_stock_data
+        from tradingagents.dataflows.y_finance import get_YFin_data_online
+
+        try:
+            if is_korean_stock(symbol):
+                data_str = get_krx_stock_data(symbol, start_date, end_date)
+            else:
+                data_str = get_YFin_data_online(symbol, start_date, end_date)
+
+            # CSV 문자열을 DataFrame으로 변환
+            lines = data_str.strip().split('\n')
+            # 실제 데이터 시작 위치 찾기 (헤더 주석 이후)
+            data_start = 0
+            for i, line in enumerate(lines):
+                if not line.startswith('#') and line.strip():
+                    data_start = i
+                    break
+
+            data_str_clean = '\n'.join(lines[data_start:])
+            df = pd.read_csv(StringIO(data_str_clean))
+
+            # 컬럼명 정리
+            df.columns = [col.strip() for col in df.columns]
+
+            # 날짜 컬럼 찾기 및 인덱스 설정
+            date_cols = [col for col in df.columns if 'date' in col.lower() or '날짜' in col]
+            if date_cols:
+                df['Date'] = pd.to_datetime(df[date_cols[0]])
+                df = df.set_index('Date')
+
+            return df, None
+        except Exception as e:
+            return None, str(e)
+
+    def get_company_info(self, symbol: str) -> Tuple[str, str]:
+        """
+        회사명 및 시장 정보 가져오기
+
+        Returns:
+            (company_name, market_info)
+        """
+        from tradingagents.dataflows.krx import is_korean_stock, get_company_name
+
+        if is_korean_stock(symbol):
+            name = get_company_name(symbol)
+            market = "한국 (KRX)"
+        else:
+            try:
+                import yfinance as yf
+                ticker = yf.Ticker(symbol)
+                info = ticker.info
+                name = info.get('longName', symbol)
+            except:
+                name = symbol
+            market = "미국"
+
+        return name, market
+
+    def get_current_price(self, symbol: str) -> Optional[float]:
+        """현재가 조회"""
+        end_date = datetime.now().strftime("%Y-%m-%d")
+        start_date = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
+
+        df, error = self.get_stock_data(symbol, start_date, end_date)
+        if df is not None and not df.empty:
+            close_col = self._find_close_column(df)
+            if close_col:
+                return float(df[close_col].iloc[-1])
+        return None
+
+    def get_current_prices(self, symbols: List[str]) -> Dict[str, float]:
+        """여러 종목 현재가 일괄 조회"""
+        prices = {}
+        for symbol in symbols:
+            price = self.get_current_price(symbol)
+            if price:
+                prices[symbol] = price
+        return prices
+
+    def _find_close_column(self, df: pd.DataFrame) -> Optional[str]:
+        """종가 컬럼 찾기"""
+        return next((c for c in df.columns if 'close' in c.lower() or '종가' in c), None)
+
+    def _find_ohlcv_columns(self, df: pd.DataFrame) -> Dict[str, Optional[str]]:
+        """OHLCV 컬럼 찾기"""
+        return {
+            'open': next((c for c in df.columns if 'open' in c.lower() or '시가' in c), None),
+            'high': next((c for c in df.columns if 'high' in c.lower() or '고가' in c), None),
+            'low': next((c for c in df.columns if 'low' in c.lower() or '저가' in c), None),
+            'close': next((c for c in df.columns if 'close' in c.lower() or '종가' in c), None),
+            'volume': next((c for c in df.columns if 'volume' in c.lower() or '거래량' in c), None)
+        }
+
+    def plot_candlestick(self, df: pd.DataFrame, symbol: str, company_name: str,
+                         show_volume: bool = True) -> Optional["go.Figure"]:
+        """캔들스틱 차트 생성"""
+        try:
+            import plotly.graph_objects as go
+            from plotly.subplots import make_subplots
+        except ImportError:
+            return None
+
+        cols = self._find_ohlcv_columns(df)
+
+        if not all([cols['open'], cols['high'], cols['low'], cols['close']]):
+            return None
+
+        # 서브플롯 생성 (거래량 포함 여부에 따라)
+        if show_volume and cols['volume']:
+            fig = make_subplots(
+                rows=2, cols=1, shared_xaxes=True,
+                vertical_spacing=0.03,
+                row_heights=[0.7, 0.3]
+            )
+        else:
+            fig = make_subplots(rows=1, cols=1)
+
+        # 캔들스틱
+        fig.add_trace(
+            go.Candlestick(
+                x=df.index,
+                open=df[cols['open']],
+                high=df[cols['high']],
+                low=df[cols['low']],
+                close=df[cols['close']],
+                name="가격",
+                increasing_line_color='red',
+                decreasing_line_color='blue'
+            ),
+            row=1, col=1
+        )
+
+        # 거래량
+        if show_volume and cols['volume']:
+            colors = [
+                'red' if df[cols['close']].iloc[i] >= df[cols['open']].iloc[i] else 'blue'
+                for i in range(len(df))
+            ]
+            fig.add_trace(
+                go.Bar(x=df.index, y=df[cols['volume']], name="거래량", marker_color=colors),
+                row=2, col=1
+            )
+            fig.update_yaxes(title_text="거래량", row=2, col=1)
+
+        fig.update_layout(
+            title=f"{company_name} ({symbol})",
+            xaxis_rangeslider_visible=False,
+            height=600,
+            showlegend=False
+        )
+
+        fig.update_xaxes(title_text="날짜", row=2 if show_volume else 1, col=1)
+        fig.update_yaxes(title_text="가격", row=1, col=1)
+
+        return fig
+
+    def plot_mini_chart(self, df: pd.DataFrame, symbol: str) -> Optional["go.Figure"]:
+        """미니 라인 차트 생성 (카드용)"""
+        try:
+            import plotly.graph_objects as go
+        except ImportError:
+            return None
+
+        close_col = self._find_close_column(df)
+        if not close_col:
+            return None
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Scatter(
+                x=df.index,
+                y=df[close_col],
+                mode='lines',
+                line=dict(color='#1E88E5', width=2),
+                fill='tozeroy',
+                fillcolor='rgba(30, 136, 229, 0.1)'
+            )
+        )
+
+        fig.update_layout(
+            height=150,
+            margin=dict(l=0, r=0, t=0, b=0),
+            showlegend=False,
+            xaxis=dict(visible=False),
+            yaxis=dict(visible=False),
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)'
+        )
+
+        return fig
+
+    def get_stock_metrics(self, df: pd.DataFrame) -> Dict:
+        """주식 주요 지표 계산"""
+        close_col = self._find_close_column(df)
+        if not close_col or df.empty:
+            return {}
+
+        current_price = df[close_col].iloc[-1]
+        prev_price = df[close_col].iloc[0]
+        change = ((current_price - prev_price) / prev_price) * 100
+        high = df[close_col].max()
+        low = df[close_col].min()
+
+        return {
+            "current_price": current_price,
+            "prev_price": prev_price,
+            "change_rate": round(change, 2),
+            "period_high": high,
+            "period_low": low,
+            "data_count": len(df)
+        }
+
+    def get_technical_indicators(self, symbol: str, start_date: str, end_date: str) -> Tuple[Optional[pd.DataFrame], Optional[str]]:
+        """기술적 지표 계산 (주식 데이터에서 직접 계산)"""
+        try:
+            # 주식 데이터 조회
+            df, error = self.get_stock_data(symbol, start_date, end_date)
+            if error or df is None or df.empty:
+                return None, error or "데이터 없음"
+
+            close_col = self._find_close_column(df)
+            if not close_col:
+                return None, "종가 컬럼을 찾을 수 없습니다"
+
+            # 기술적 ���표 계산
+            close = df[close_col]
+
+            # RSI (14일)
+            delta = close.diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+            rs = gain / loss
+            df['RSI'] = 100 - (100 / (1 + rs))
+
+            # MACD
+            exp12 = close.ewm(span=12, adjust=False).mean()
+            exp26 = close.ewm(span=26, adjust=False).mean()
+            df['MACD'] = exp12 - exp26
+            df['Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
+            df['MACD_Hist'] = df['MACD'] - df['Signal']
+
+            # Bollinger Bands
+            sma20 = close.rolling(window=20).mean()
+            std20 = close.rolling(window=20).std()
+            df['BB_upper'] = sma20 + (std20 * 2)
+            df['BB_middle'] = sma20
+            df['BB_lower'] = sma20 - (std20 * 2)
+
+            return df, None
+        except Exception as e:
+            return None, str(e)
+
+    def plot_indicators(self, df: pd.DataFrame, indicator_type: str = "RSI") -> Optional["go.Figure"]:
+        """기술지표 차트 생성"""
+        try:
+            import plotly.graph_objects as go
+        except ImportError:
+            return None
+
+        fig = go.Figure()
+
+        if indicator_type == "RSI" and 'RSI' in df.columns:
+            fig.add_trace(go.Scatter(
+                x=df.index, y=df['RSI'],
+                mode='lines', name='RSI',
+                line=dict(color='purple', width=2)
+            ))
+            fig.add_hline(y=70, line_dash="dash", line_color="red", annotation_text="과매수 (70)")
+            fig.add_hline(y=30, line_dash="dash", line_color="green", annotation_text="과매도 (30)")
+            fig.update_layout(title="RSI (Relative Strength Index)", yaxis_range=[0, 100])
+
+        elif indicator_type == "MACD":
+            if 'MACD' in df.columns and 'Signal' in df.columns:
+                fig.add_trace(go.Scatter(x=df.index, y=df['MACD'], mode='lines', name='MACD'))
+                fig.add_trace(go.Scatter(x=df.index, y=df['Signal'], mode='lines', name='Signal'))
+                if 'MACD_Hist' in df.columns:
+                    colors = ['green' if v >= 0 else 'red' for v in df['MACD_Hist']]
+                    fig.add_trace(go.Bar(x=df.index, y=df['MACD_Hist'], name='Histogram', marker_color=colors))
+                fig.update_layout(title="MACD")
+
+        elif indicator_type == "BB" and all(c in df.columns for c in ['BB_upper', 'BB_middle', 'BB_lower']):
+            close_col = self._find_close_column(df)
+            if close_col:
+                fig.add_trace(go.Scatter(x=df.index, y=df[close_col], mode='lines', name='Price'))
+            fig.add_trace(go.Scatter(x=df.index, y=df['BB_upper'], mode='lines', name='Upper', line=dict(dash='dash')))
+            fig.add_trace(go.Scatter(x=df.index, y=df['BB_middle'], mode='lines', name='Middle'))
+            fig.add_trace(go.Scatter(x=df.index, y=df['BB_lower'], mode='lines', name='Lower', line=dict(dash='dash')))
+            fig.update_layout(title="Bollinger Bands")
+
+        fig.update_layout(height=300, showlegend=True)
+        return fig

tradingagents/agents/__init__.py

@@ -0,0 +1,42 @@
+from .utils.agent_utils import 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 .analysts.timeseries_analyst import create_timeseries_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",
+    "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_timeseries_analyst",
+    "create_trader",
+]

tradingagents/agents/analysts/fundamentals_analyst.py

@@ -0,0 +1,64 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+import time
+import json
+from tradingagents.agents.utils.agent_utils import get_fundamentals, get_balance_sheet, get_cashflow, get_income_statement, get_insider_sentiment, get_insider_transactions, KOREAN_INSTRUCTION
+from tradingagents.dataflows.config import get_config
+
+
+def create_fundamentals_analyst(llm):
+    def fundamentals_analyst_node(state):
+        current_date = state["trade_date"]
+        ticker = state["company_of_interest"]
+        company_name = state["company_of_interest"]
+
+        tools = [
+            get_fundamentals,
+            get_balance_sheet,
+            get_cashflow,
+            get_income_statement,
+        ]
+
+        system_message = (
+            KOREAN_INSTRUCTION +
+            "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, and company financial history 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 Markdown table at the end of the report to organize key points in the report, organized and easy to read."
+            + " Use the available tools: `get_fundamentals` for comprehensive company analysis, `get_balance_sheet`, `get_cashflow`, and `get_income_statement` for specific financial statements.",
+        )
+
+        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"])
+
+        report = ""
+
+        if len(result.tool_calls) == 0:
+            report = result.content
+
+        return {
+            "messages": [result],
+            "fundamentals_report": report,
+        }
+
+    return fundamentals_analyst_node

tradingagents/agents/analysts/market_analyst.py

@@ -0,0 +1,86 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+import time
+import json
+from tradingagents.agents.utils.agent_utils import get_stock_data, get_indicators, KOREAN_INSTRUCTION
+from tradingagents.dataflows.config import get_config
+
+
+def create_market_analyst(llm):
+
+    def market_analyst_node(state):
+        current_date = state["trade_date"]
+        ticker = state["company_of_interest"]
+        company_name = state["company_of_interest"]
+
+        tools = [
+            get_stock_data,
+            get_indicators,
+        ]
+
+        system_message = (
+            KOREAN_INSTRUCTION +
+            """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_stock_data first to retrieve the CSV that is needed to generate indicators. Then use get_indicators with the specific indicator names. 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"])
+
+        report = ""
+
+        if len(result.tool_calls) == 0:
+            report = result.content
+       
+        return {
+            "messages": [result],
+            "market_report": report,
+        }
+
+    return market_analyst_node

tradingagents/agents/analysts/news_analyst.py

@@ -0,0 +1,59 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+import time
+import json
+from tradingagents.agents.utils.agent_utils import get_news, get_global_news, KOREAN_INSTRUCTION
+from tradingagents.dataflows.config import get_config
+
+
+def create_news_analyst(llm):
+    def news_analyst_node(state):
+        current_date = state["trade_date"]
+        ticker = state["company_of_interest"]
+
+        tools = [
+            get_news,
+            get_global_news,
+        ]
+
+        system_message = (
+            KOREAN_INSTRUCTION +
+            "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. Use the available tools: get_news(query, start_date, end_date) for company-specific or targeted news searches, and get_global_news(curr_date, look_back_days, limit) for broader macroeconomic 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 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}. 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"])
+
+        report = ""
+
+        if len(result.tool_calls) == 0:
+            report = result.content
+
+        return {
+            "messages": [result],
+            "news_report": report,
+        }
+
+    return news_analyst_node

tradingagents/agents/analysts/social_media_analyst.py

@@ -0,0 +1,60 @@
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+import time
+import json
+from tradingagents.agents.utils.agent_utils import get_news, KOREAN_INSTRUCTION
+from tradingagents.dataflows.config import get_config
+
+
+def create_social_media_analyst(llm):
+    def social_media_analyst_node(state):
+        current_date = state["trade_date"]
+        ticker = state["company_of_interest"]
+        company_name = state["company_of_interest"]
+
+        tools = [
+            get_news,
+        ]
+
+        system_message = (
+            KOREAN_INSTRUCTION +
+            "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. Use the get_news(query, start_date, end_date) tool to search for company-specific news and social media discussions. 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 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 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"])
+
+        report = ""
+
+        if len(result.tool_calls) == 0:
+            report = result.content
+
+        return {
+            "messages": [result],
+            "sentiment_report": report,
+        }
+
+    return social_media_analyst_node

tradingagents/agents/analysts/timeseries_analyst.py

@@ -0,0 +1,204 @@
+"""
+시계열 분석가 에이전트
+AI가 자동으로 관련 변수를 발견하고 시계열 예측을 수행합니다.
+딥러닝 앙상블 모델 (DLinear, NHITS, NBEATS) 지원
+"""
+
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+from tradingagents.agents.utils.timeseries_tools import (
+    get_macro_indicators,
+    get_sector_performance,
+    get_correlated_assets,
+    analyze_stock_for_forecasting,
+    run_simple_forecast,
+    collect_forecast_features,
+    run_ensemble_forecast,  # 딥러닝 앙상블 예측 추가
+)
+
+
+def create_timeseries_analyst(llm):
+    """
+    시계열 분석가 에이전트를 생성합니다.
+    
+    이 에이전트는:
+    1. 종목의 특성을 분석하여 관련 변수를 자동으로 식별
+    2. 거시경제 지표, 섹터 데이터, 상관관계 분석
+    3. 시계열 예측 수행
+    
+    Args:
+        llm: LangChain LLM 인스턴스
+    
+    Returns:
+        시계열 분석가 노드 함수
+    """
+    
+    def timeseries_analyst_node(state):
+        current_date = state["trade_date"]
+        ticker = state["company_of_interest"]
+        
+        tools = [
+            analyze_stock_for_forecasting,  # 종목 분석 및 변수 식별
+            get_macro_indicators,           # 거시경제 지표
+            get_sector_performance,         # 섹터 성과
+            get_correlated_assets,          # 상관관계 분석
+            collect_forecast_features,      # 특성 데이터 수집
+            run_simple_forecast,            # 기술적 분석 기반 예측
+            run_ensemble_forecast,          # 딥러닝 앙상블 예측 (DLinear+NHITS+NBEATS)
+        ]
+        
+        system_message = KOREAN_INSTRUCTION + """You are an expert Time Series Analyst specializing in stock price forecasting using multiple data sources and deep learning models.
+
+Your task is to perform a comprehensive time series analysis that:
+
+1. **Variable Discovery**: First, analyze the stock to understand:
+   - What sector/industry does this company belong to?
+   - What macro-economic factors typically affect this type of stock?
+   - What other assets are correlated with this stock?
+
+2. **Data Collection**: Gather relevant data:
+   - Use `analyze_stock_for_forecasting` to identify key features
+   - Use `get_macro_indicators` to get current economic environment
+   - Use `get_sector_performance` to understand sector trends
+   - Use `get_correlated_assets` to find empirical correlations
+
+3. **Forecasting**: Run predictions using BOTH methods:
+   - Use `run_simple_forecast` for technical indicator-based forecast
+   - Use `run_ensemble_forecast` for deep learning ensemble forecast (DLinear+NHITS+NBEATS)
+   - Compare both forecasts and synthesize the final prediction
+
+4. **Report Generation**: Write a detailed report including:
+   - Key variables identified and why they matter for this stock
+   - Current macro environment assessment
+   - Sector positioning
+   - Technical analysis forecast results
+   - Deep learning ensemble forecast results
+   - Final synthesized prediction with confidence level
+   - Risk factors to watch
+
+**Important Guidelines**:
+- ALWAYS run BOTH forecast methods (run_simple_forecast AND run_ensemble_forecast)
+- The ensemble forecast uses 3 neural network models: DLinear (30%), NHITS (40%), NBEATS (30%)
+- Compare the technical and ML-based forecasts to improve confidence
+- DO NOT just list data - provide INSIGHTS and ANALYSIS
+- Explain WHY certain variables matter for this specific stock
+- Be specific about the forecast direction and reasoning
+- Include actionable information for traders
+
+Make sure to append a Markdown table at the end summarizing:
+| Factor | Current Status | Impact on Forecast |
+
+And a comparison table:
+| Method | Predicted Price | Change % | Signal |
+"""
+
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    "You are a helpful AI assistant specialized in time series forecasting, collaborating with other assistants."
+                    " Use the provided tools to analyze the stock and make predictions."
+                    " 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 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"])
+        
+        report = ""
+        
+        if len(result.tool_calls) == 0:
+            report = result.content
+        
+        return {
+            "messages": [result],
+            "timeseries_report": report,
+        }
+    
+    return timeseries_analyst_node
+
+
+def create_variable_discovery_agent(llm):
+    """
+    변수 발견 전문 에이전트를 생성합니다.
+    LLM이 종목의 특성을 분석하여 예측에 필요한 변수를 자동으로 식별합니다.
+    
+    Args:
+        llm: LangChain LLM 인스턴스
+    
+    Returns:
+        변수 발견 에이전트 노드 함수
+    """
+    
+    def variable_discovery_node(state):
+        ticker = state["company_of_interest"]
+        current_date = state["trade_date"]
+        
+        # LLM에게 직접 종목 분석 요청
+        discovery_prompt = f"""Analyze the stock {ticker} and identify all relevant variables that could affect its price.
+
+Consider the following categories:
+
+1. **Sector/Industry Factors**:
+   - What sector does this company belong to?
+   - What are the key drivers for this sector?
+   - Which sector ETFs track this industry?
+
+2. **Macro-Economic Factors**:
+   - Interest rates sensitivity
+   - Currency exposure (dollar strength)
+   - Commodity dependencies (oil, metals, etc.)
+   - Consumer spending correlation
+
+3. **Market Factors**:
+   - Beta to S&P 500
+   - VIX sensitivity
+   - Growth vs Value characteristics
+
+4. **Company-Specific Factors**:
+   - Key customers/suppliers
+   - Competitive dynamics
+   - Regulatory environment
+
+5. **Seasonal/Cyclical Patterns**:
+   - Earnings seasonality
+   - Holiday effects
+   - Economic cycle sensitivity
+
+Please provide a structured JSON response with:
+{{
+    "ticker": "{ticker}",
+    "sector": "...",
+    "industry": "...",
+    "recommended_features": [
+        {{"name": "...", "type": "macro/sector/market/specific", "reason": "..."}},
+        ...
+    ],
+    "key_risks": ["...", "..."],
+    "seasonality_notes": "..."
+}}
+"""
+        
+        response = llm.invoke(discovery_prompt)
+        
+        return {
+            "messages": [response],
+            "discovered_variables": response.content,
+        }
+    
+    return variable_discovery_node

tradingagents/agents/managers/research_manager.py

@@ -0,0 +1,56 @@
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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 = KOREAN_INSTRUCTION + 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

tradingagents/agents/managers/risk_manager.py

@@ -0,0 +1,67 @@
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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 = KOREAN_INSTRUCTION + 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

tradingagents/agents/researchers/bear_researcher.py

@@ -0,0 +1,65 @@
+from langchain_core.messages import AIMessage
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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"]
+        timeseries_report = state.get("timeseries_report", "")
+
+        curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}\n\n{timeseries_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 = KOREAN_INSTRUCTION + 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.
+- Time Series Forecast: Consider the AI-driven price forecast uncertainties and technical warning signals.
+- 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}
+Time series forecast report: {timeseries_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

tradingagents/agents/researchers/bull_researcher.py

@@ -0,0 +1,63 @@
+from langchain_core.messages import AIMessage
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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"]
+        timeseries_report = state.get("timeseries_report", "")
+
+        curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}\n\n{timeseries_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 = KOREAN_INSTRUCTION + 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.
+- Time Series Forecast: Consider the AI-driven price forecast and technical signals.
+- 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}
+Time series forecast report: {timeseries_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

tradingagents/agents/risk_mgmt/aggresive_debator.py

@@ -0,0 +1,56 @@
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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 = KOREAN_INSTRUCTION + 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

tradingagents/agents/risk_mgmt/conservative_debator.py

@@ -0,0 +1,59 @@
+from langchain_core.messages import AIMessage
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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 = KOREAN_INSTRUCTION + 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

tradingagents/agents/risk_mgmt/neutral_debator.py

@@ -0,0 +1,56 @@
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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 = KOREAN_INSTRUCTION + 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

tradingagents/agents/trader/trader.py

@@ -0,0 +1,47 @@
+import functools
+import time
+import json
+from tradingagents.agents.utils.agent_utils import KOREAN_INSTRUCTION
+
+
+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 = ""
+        if past_memories:
+            for i, rec in enumerate(past_memories, 1):
+                past_memory_str += rec["recommendation"] + "\n\n"
+        else:
+            past_memory_str = "No past memories found."
+
+        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": KOREAN_INSTRUCTION + 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")

tradingagents/agents/utils/agent_states.py

@@ -0,0 +1,77 @@
+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"]
+    timeseries_report: Annotated[str, "Report from the Time Series Analyst with forecast"]
+
+    # researcher team discussion step
+    investment_debate_state: Annotated[
+        InvestDebateState, "Current state of the debate on if to invest or not"
+    ]
+    investment_plan: Annotated[str, "Plan generated by the Analyst"]
+
+    trader_investment_plan: Annotated[str, "Plan generated by the Trader"]
+
+    # risk management team discussion step
+    risk_debate_state: Annotated[
+        RiskDebateState, "Current state of the debate on evaluating risk"
+    ]
+    final_trade_decision: Annotated[str, "Final decision made by the Risk Analysts"]

tradingagents/agents/utils/agent_utils.py

@@ -0,0 +1,44 @@
+from langchain_core.messages import HumanMessage, RemoveMessage
+
+# 한글 응답 지시 (모든 에이전트 프롬프트에 추가)
+KOREAN_INSTRUCTION = """
+[중요: 모든 응답을 한국어로 작성하세요. 분석 리포트, 의견, 결론 모두 한국어로 작성합니다.]
+"""
+
+# Import tools from separate utility files
+from tradingagents.agents.utils.core_stock_tools import (
+    get_stock_data
+)
+from tradingagents.agents.utils.technical_indicators_tools import (
+    get_indicators
+)
+from tradingagents.agents.utils.fundamental_data_tools import (
+    get_fundamentals,
+    get_balance_sheet,
+    get_cashflow,
+    get_income_statement
+)
+from tradingagents.agents.utils.news_data_tools import (
+    get_news,
+    get_insider_sentiment,
+    get_insider_transactions,
+    get_global_news
+)
+
+def create_msg_delete():
+    def delete_messages(state):
+        """Clear messages and add placeholder for Anthropic compatibility"""
+        messages = state["messages"]
+        
+        # Remove all messages
+        removal_operations = [RemoveMessage(id=m.id) for m in messages]
+        
+        # Add a minimal placeholder message
+        placeholder = HumanMessage(content="Continue")
+        
+        return {"messages": removal_operations + [placeholder]}
+    
+    return delete_messages
+
+
+        

tradingagents/agents/utils/core_stock_tools.py

@@ -0,0 +1,22 @@
+from langchain_core.tools import tool
+from typing import Annotated
+from tradingagents.dataflows.interface import route_to_vendor
+
+
+@tool
+def get_stock_data(
+    symbol: Annotated[str, "ticker symbol of the company"],
+    start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+    end_date: Annotated[str, "End date in yyyy-mm-dd format"],
+) -> str:
+    """
+    Retrieve stock price data (OHLCV) for a given ticker symbol.
+    Uses the configured core_stock_apis vendor.
+    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.
+    """
+    return route_to_vendor("get_stock_data", symbol, start_date, end_date)

tradingagents/agents/utils/fundamental_data_tools.py

@@ -0,0 +1,77 @@
+from langchain_core.tools import tool
+from typing import Annotated
+from tradingagents.dataflows.interface import route_to_vendor
+
+
+@tool
+def get_fundamentals(
+    ticker: Annotated[str, "ticker symbol"],
+    curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"],
+) -> str:
+    """
+    Retrieve comprehensive fundamental data for a given ticker symbol.
+    Uses the configured fundamental_data vendor.
+    Args:
+        ticker (str): Ticker symbol of the company
+        curr_date (str): Current date you are trading at, yyyy-mm-dd
+    Returns:
+        str: A formatted report containing comprehensive fundamental data
+    """
+    return route_to_vendor("get_fundamentals", ticker, curr_date)
+
+
+@tool
+def get_balance_sheet(
+    ticker: Annotated[str, "ticker symbol"],
+    freq: Annotated[str, "reporting frequency: annual/quarterly"] = "quarterly",
+    curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"] = None,
+) -> str:
+    """
+    Retrieve balance sheet data for a given ticker symbol.
+    Uses the configured fundamental_data vendor.
+    Args:
+        ticker (str): Ticker symbol of the company
+        freq (str): Reporting frequency: annual/quarterly (default quarterly)
+        curr_date (str): Current date you are trading at, yyyy-mm-dd
+    Returns:
+        str: A formatted report containing balance sheet data
+    """
+    return route_to_vendor("get_balance_sheet", ticker, freq, curr_date)
+
+
+@tool
+def get_cashflow(
+    ticker: Annotated[str, "ticker symbol"],
+    freq: Annotated[str, "reporting frequency: annual/quarterly"] = "quarterly",
+    curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"] = None,
+) -> str:
+    """
+    Retrieve cash flow statement data for a given ticker symbol.
+    Uses the configured fundamental_data vendor.
+    Args:
+        ticker (str): Ticker symbol of the company
+        freq (str): Reporting frequency: annual/quarterly (default quarterly)
+        curr_date (str): Current date you are trading at, yyyy-mm-dd
+    Returns:
+        str: A formatted report containing cash flow statement data
+    """
+    return route_to_vendor("get_cashflow", ticker, freq, curr_date)
+
+
+@tool
+def get_income_statement(
+    ticker: Annotated[str, "ticker symbol"],
+    freq: Annotated[str, "reporting frequency: annual/quarterly"] = "quarterly",
+    curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"] = None,
+) -> str:
+    """
+    Retrieve income statement data for a given ticker symbol.
+    Uses the configured fundamental_data vendor.
+    Args:
+        ticker (str): Ticker symbol of the company
+        freq (str): Reporting frequency: annual/quarterly (default quarterly)
+        curr_date (str): Current date you are trading at, yyyy-mm-dd
+    Returns:
+        str: A formatted report containing income statement data
+    """
+    return route_to_vendor("get_income_statement", ticker, freq, curr_date)

tradingagents/agents/utils/memory.py

@@ -0,0 +1,114 @@
+import chromadb
+from chromadb.config import Settings
+from openai import OpenAI
+
+
+class FinancialSituationMemory:
+    def __init__(self, name, config):
+        if config["backend_url"] == "http://localhost:11434/v1":
+            self.embedding = "nomic-embed-text"
+        else:
+            self.embedding = "text-embedding-3-small"
+        self.client = OpenAI(base_url=config["backend_url"])
+        self.chroma_client = chromadb.Client(Settings(allow_reset=True))
+        # get_or_create_collection을 사용하여 중복 생성 오류 방지
+        self.situation_collection = self.chroma_client.get_or_create_collection(name=name)
+
+    def get_embedding(self, text):
+        """Get OpenAI embedding for a text"""
+        
+        response = self.client.embeddings.create(
+            model=self.embedding, 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)}")

tradingagents/agents/utils/news_data_tools.py

@@ -0,0 +1,71 @@
+from langchain_core.tools import tool
+from typing import Annotated
+from tradingagents.dataflows.interface import route_to_vendor
+
+@tool
+def get_news(
+    ticker: Annotated[str, "Ticker symbol"],
+    start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
+    end_date: Annotated[str, "End date in yyyy-mm-dd format"],
+) -> str:
+    """
+    Retrieve news data for a given ticker symbol.
+    Uses the configured news_data vendor.
+    Args:
+        ticker (str): Ticker symbol
+        start_date (str): Start date in yyyy-mm-dd format
+        end_date (str): End date in yyyy-mm-dd format
+    Returns:
+        str: A formatted string containing news data
+    """
+    return route_to_vendor("get_news", ticker, start_date, end_date)
+
+@tool
+def get_global_news(
+    curr_date: Annotated[str, "Current date in yyyy-mm-dd format"],
+    look_back_days: Annotated[int, "Number of days to look back"] = 7,
+    limit: Annotated[int, "Maximum number of articles to return"] = 5,
+) -> str:
+    """
+    Retrieve global news data.
+    Uses the configured news_data vendor.
+    Args:
+        curr_date (str): Current date in yyyy-mm-dd format
+        look_back_days (int): Number of days to look back (default 7)
+        limit (int): Maximum number of articles to return (default 5)
+    Returns:
+        str: A formatted string containing global news data
+    """
+    return route_to_vendor("get_global_news", curr_date, look_back_days, limit)
+
+@tool
+def get_insider_sentiment(
+    ticker: Annotated[str, "ticker symbol for the company"],
+    curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"],
+) -> str:
+    """
+    Retrieve insider sentiment information about a company.
+    Uses the configured news_data vendor.
+    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 insider sentiment data
+    """
+    return route_to_vendor("get_insider_sentiment", ticker, curr_date)
+
+@tool
+def get_insider_transactions(
+    ticker: Annotated[str, "ticker symbol"],
+    curr_date: Annotated[str, "current date you are trading at, yyyy-mm-dd"],
+) -> str:
+    """
+    Retrieve insider transaction information about a company.
+    Uses the configured news_data vendor.
+    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 insider transaction data
+    """
+    return route_to_vendor("get_insider_transactions", ticker, curr_date)

tradingagents/agents/utils/technical_indicators_tools.py

@@ -0,0 +1,23 @@
+from langchain_core.tools import tool
+from typing import Annotated
+from tradingagents.dataflows.interface import route_to_vendor
+
+@tool
+def get_indicators(
+    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 technical indicators for a given ticker symbol.
+    Uses the configured technical_indicators vendor.
+    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 technical indicators for the specified ticker symbol and indicator.
+    """
+    return route_to_vendor("get_indicators", symbol, indicator, curr_date, look_back_days)

tradingagents/agents/utils/timeseries_tools.py

@@ -0,0 +1,981 @@
+"""
+시계열 분석 도구 모듈
+LLM 에이전트가 사용할 수 있는 시계열 분석/예측 도구들
+딥러닝 기반 앙상블 예측 포함 (DLinear, NHITS, NBEATS)
+"""
+
+from langchain_core.tools import tool
+from typing import Annotated, List, Dict, Any, Optional
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import json
+import yfinance as yf
+import gc
+import warnings
+warnings.filterwarnings('ignore')
+
+from tradingagents.dataflows.macro_data import (
+    get_macro_summary,
+    get_all_macro_features,
+    get_related_sector_data,
+    get_yahoo_macro_data,
+    get_sector_etf_data,
+    SECTOR_ETFS,
+    YAHOO_MACRO_TICKERS,
+    TICKER_SECTOR_MAP,
+)
+
+
+@tool
+def get_macro_indicators(
+    end_date: Annotated[str, "The end date for macro data, YYYY-MM-DD format"],
+    indicators: Annotated[List[str], "List of macro indicators to fetch. Options: vix, dollar_index, gold, oil_wti, oil_brent, natural_gas, copper, sp500_index, nasdaq, treasury_10y"] = None,
+) -> str:
+    """
+    거시경제 지표 데이터를 가져옵니다.
+    금리, VIX, 달러 인덱스, 원자재 가격 등 시장에 영향을 미치는 거시경제 데이터를 수집합니다.
+    
+    Args:
+        end_date: 기준 날짜
+        indicators: 가져올 지표 목록 (None이면 주요 지표 모두)
+    
+    Returns:
+        거시경제 지표 요약 문자열
+    """
+    try:
+        summary = get_macro_summary(end_date, lookback_days=90)
+        
+        if not summary:
+            return "Failed to fetch macro indicators. Please check the date."
+        
+        result = f"# Macro Economic Indicators as of {end_date}\n\n"
+        
+        for indicator, data in summary.items():
+            result += f"## {indicator.upper().replace('_', ' ')}\n"
+            for key, value in data.items():
+                if isinstance(value, float):
+                    if 'change' in key:
+                        result += f"- {key}: {value:+.2f}%\n"
+                    else:
+                        result += f"- {key}: {value:.2f}\n"
+                else:
+                    result += f"- {key}: {value}\n"
+            result += "\n"
+        
+        return result
+    except Exception as e:
+        return f"Error fetching macro indicators: {str(e)}"
+
+
+@tool
+def get_sector_performance(
+    end_date: Annotated[str, "The end date for sector data, YYYY-MM-DD format"],
+    sectors: Annotated[List[str], "List of sectors. Options: technology, healthcare, financials, energy, semiconductors, consumer_discretionary, industrials, materials, utilities, real_estate, communication"] = None,
+    lookback_days: Annotated[int, "Number of days to look back"] = 30,
+) -> str:
+    """
+    섹터별 성과 데이터를 가져옵니다.
+    섹터 ETF의 수익률과 변동성을 분석하여 시장 동향을 파악합니다.
+    
+    Args:
+        end_date: 기준 날짜
+        sectors: 분석할 섹터 목록
+        lookback_days: 과거 데이터 기간
+    
+    Returns:
+        섹터별 성과 분석 문자열
+    """
+    if sectors is None:
+        sectors = ["technology", "healthcare", "financials", "energy", "semiconductors"]
+    
+    end_dt = pd.to_datetime(end_date)
+    start_dt = end_dt - timedelta(days=lookback_days + 30)  # 여유 기간
+    start_date = start_dt.strftime("%Y-%m-%d")
+    
+    result = f"# Sector Performance Analysis ({lookback_days} days ending {end_date})\n\n"
+    
+    sector_data = []
+    for sector in sectors:
+        try:
+            data = get_sector_etf_data(sector, start_date, end_date)
+            if not data.empty:
+                close_col = f"{sector}_close"
+                if close_col in data.columns:
+                    prices = data[close_col].dropna()
+                    if len(prices) >= 2:
+                        returns = float((prices.iloc[-1] / prices.iloc[0] - 1) * 100)
+                        volatility = float(prices.pct_change().std() * np.sqrt(252) * 100)
+                        current_price = float(prices.iloc[-1])
+                        
+                        sector_data.append({
+                            "sector": sector,
+                            "return": returns,
+                            "volatility": volatility,
+                            "current": current_price
+                        })
+        except Exception as e:
+            continue
+    
+    if sector_data:
+        # 수익률 기준 정렬
+        sector_data.sort(key=lambda x: x["return"], reverse=True)
+        
+        result += "| Sector | Return | Volatility (Ann.) | Current Price |\n"
+        result += "|--------|--------|-------------------|---------------|\n"
+        
+        for s in sector_data:
+            result += f"| {s['sector'].title()} | {s['return']:+.2f}% | {s['volatility']:.2f}% | ${s['current']:.2f} |\n"
+        
+        # 요약
+        result += f"\n## Summary\n"
+        best = sector_data[0]
+        worst = sector_data[-1]
+        result += f"- **Best performing**: {best['sector'].title()} ({best['return']:+.2f}%)\n"
+        result += f"- **Worst performing**: {worst['sector'].title()} ({worst['return']:+.2f}%)\n"
+    else:
+        result += "No sector data available.\n"
+    
+    return result
+
+
+@tool
+def get_correlated_assets(
+    symbol: Annotated[str, "The stock ticker symbol to find correlations for"],
+    end_date: Annotated[str, "The end date, YYYY-MM-DD format"],
+    lookback_days: Annotated[int, "Number of days to calculate correlation"] = 90,
+) -> str:
+    """
+    주어진 종목과 상관관계가 높은 자산들을 찾습니다.
+    섹터 ETF, 지수, 원자재 등과의 상관관계를 분석합니다.
+    
+    Args:
+        symbol: 분석할 종목 티커
+        end_date: 기준 날짜
+        lookback_days: 상관관계 계산 기간
+    
+    Returns:
+        상관관계 분석 결과 문자열
+    """
+    end_dt = pd.to_datetime(end_date)
+    start_dt = end_dt - timedelta(days=lookback_days + 30)
+    start_date = start_dt.strftime("%Y-%m-%d")
+    
+    try:
+        # 대상 종목 데이터
+        target_data = yf.download(symbol, start=start_date, end=end_date, progress=False)
+        if target_data.empty:
+            return f"No data found for {symbol}"
+        
+        # MultiIndex columns 처리
+        if isinstance(target_data.columns, pd.MultiIndex):
+            target_data.columns = target_data.columns.get_level_values(0)
+        
+        target_returns = target_data["Close"].pct_change().dropna()
+        
+        # 비교할 자산들
+        comparison_assets = {
+            # 지수
+            "S&P 500": "^GSPC",
+            "NASDAQ": "^IXIC",
+            "Russell 2000": "^RUT",
+            # 섹터 ETF
+            "Technology (XLK)": "XLK",
+            "Semiconductors (SOXX)": "SOXX",
+            "Energy (XLE)": "XLE",
+            "Financials (XLF)": "XLF",
+            # 거시
+            "VIX": "^VIX",
+            "Gold": "GC=F",
+            "Oil WTI": "CL=F",
+            "Dollar Index": "DX-Y.NYB",
+        }
+        
+        correlations = []
+        
+        for name, ticker in comparison_assets.items():
+            try:
+                comp_data = yf.download(ticker, start=start_date, end=end_date, progress=False)
+                if not comp_data.empty:
+                    # MultiIndex columns 처리
+                    if isinstance(comp_data.columns, pd.MultiIndex):
+                        comp_data.columns = comp_data.columns.get_level_values(0)
+                    
+                    comp_returns = comp_data["Close"].pct_change().dropna()
+                    
+                    # 날짜 정렬
+                    aligned = pd.concat([target_returns, comp_returns], axis=1).dropna()
+                    if len(aligned) > 10:
+                        corr = aligned.iloc[:, 0].corr(aligned.iloc[:, 1])
+                        correlations.append({"asset": name, "correlation": corr})
+            except:
+                continue
+        
+        if not correlations:
+            return f"Could not calculate correlations for {symbol}"
+        
+        # 상관관계 절대값 기준 정렬
+        correlations.sort(key=lambda x: abs(x["correlation"]), reverse=True)
+        
+        result = f"# Correlation Analysis for {symbol}\n"
+        result += f"Period: {lookback_days} days ending {end_date}\n\n"
+        
+        result += "| Asset | Correlation |\n"
+        result += "|-------|-------------|\n"
+        
+        for c in correlations:
+            corr_val = c["correlation"]
+            if corr_val > 0.7:
+                strength = "🟢 Strong positive"
+            elif corr_val > 0.4:
+                strength = "🔵 Moderate positive"
+            elif corr_val > -0.4:
+                strength = "⚪ Weak"
+            elif corr_val > -0.7:
+                strength = "🟠 Moderate negative"
+            else:
+                strength = "🔴 Strong negative"
+            
+            result += f"| {c['asset']} | {corr_val:+.3f} ({strength}) |\n"
+        
+        # 인사이트
+        result += "\n## Key Insights\n"
+        
+        high_positive = [c for c in correlations if c["correlation"] > 0.6]
+        high_negative = [c for c in correlations if c["correlation"] < -0.4]
+        
+        if high_positive:
+            result += f"- **Moves with**: {', '.join([c['asset'] for c in high_positive[:3]])}\n"
+        if high_negative:
+            result += f"- **Hedges against**: {', '.join([c['asset'] for c in high_negative[:3]])}\n"
+        
+        return result
+    
+    except Exception as e:
+        return f"Error calculating correlations: {str(e)}"
+
+
+@tool
+def analyze_stock_for_forecasting(
+    symbol: Annotated[str, "The stock ticker symbol to analyze"],
+    end_date: Annotated[str, "The analysis date, YYYY-MM-DD format"],
+) -> str:
+    """
+    주식의 특성을 분석하여 시계열 예측에 필요한 변수들을 식별합니다.
+    종목의 섹터, 관련 지수, 영향을 미치는 거시��제 요인 등을 분석합니다.
+    
+    Args:
+        symbol: 분석할 종목 티커
+        end_date: 기준 날짜
+    
+    Returns:
+        종목 분석 및 추천 변수 목록
+    """
+    try:
+        # yfinance로 종목 정보 가져오기
+        stock = yf.Ticker(symbol)
+        info = stock.info
+        
+        result = f"# Stock Analysis for Time Series Forecasting: {symbol}\n\n"
+        
+        # 기본 정보
+        result += "## Company Information\n"
+        result += f"- **Name**: {info.get('longName', 'N/A')}\n"
+        result += f"- **Sector**: {info.get('sector', 'N/A')}\n"
+        result += f"- **Industry**: {info.get('industry', 'N/A')}\n"
+        result += f"- **Market Cap**: ${info.get('marketCap', 0)/1e9:.2f}B\n"
+        
+        # 미리 정의된 섹터 매핑 확인
+        known_sectors = TICKER_SECTOR_MAP.get(symbol.upper(), [])
+        
+        result += "\n## Recommended Features for Forecasting\n"
+        
+        # 섹터 기반 추천
+        sector = info.get('sector', '').lower()
+        industry = info.get('industry', '').lower()
+        
+        recommended_features = []
+        
+        # 기본 시장 지표
+        recommended_features.extend([
+            ("S&P 500 Index", "Market benchmark"),
+            ("VIX", "Market volatility/fear gauge"),
+        ])
+        
+        # 섹터별 추천
+        if 'technology' in sector or 'semiconductor' in industry:
+            recommended_features.extend([
+                ("NASDAQ Index", "Tech-heavy index correlation"),
+                ("Semiconductors ETF (SOXX)", "Sector performance"),
+                ("Technology ETF (XLK)", "Broad tech sector"),
+            ])
+        
+        if 'energy' in sector or 'oil' in industry:
+            recommended_features.extend([
+                ("Oil WTI", "Commodity price driver"),
+                ("Natural Gas", "Energy commodity"),
+                ("Energy ETF (XLE)", "Sector performance"),
+            ])
+        
+        if 'financial' in sector or 'bank' in industry:
+            recommended_features.extend([
+                ("10Y Treasury Yield", "Interest rate sensitivity"),
+                ("Yield Spread (10Y-2Y)", "Economic outlook indicator"),
+                ("Financials ETF (XLF)", "Sector performance"),
+            ])
+        
+        # 공통 거시경제 지표
+        recommended_features.extend([
+            ("Dollar Index", "Currency impact"),
+            ("Gold", "Safe haven indicator"),
+            ("10Y Treasury Yield", "Risk-free rate benchmark"),
+        ])
+        
+        # 중복 제거
+        seen = set()
+        unique_features = []
+        for f in recommended_features:
+            if f[0] not in seen:
+                seen.add(f[0])
+                unique_features.append(f)
+        
+        result += "\n| Feature | Reason |\n"
+        result += "|---------|--------|\n"
+        for feature, reason in unique_features:
+            result += f"| {feature} | {reason} |\n"
+        
+        # 상관관계 기반 추가 분석 제안
+        result += "\n## Additional Analysis Suggestions\n"
+        result += "- Use `get_correlated_assets` to find empirical correlations\n"
+        result += "- Use `get_sector_performance` to compare sector trends\n"
+        result += "- Use `get_macro_indicators` to get current macro environment\n"
+        
+        return result
+    
+    except Exception as e:
+        return f"Error analyzing stock: {str(e)}"
+
+
+@tool
+def run_simple_forecast(
+    symbol: Annotated[str, "The stock ticker symbol to forecast"],
+    end_date: Annotated[str, "The forecast start date, YYYY-MM-DD format"],
+    forecast_days: Annotated[int, "Number of days to forecast"] = 30,
+    include_features: Annotated[List[str], "Additional features to include: vix, gold, oil_wti, dollar_index, sector"] = None,
+) -> str:
+    """
+    간단한 시계열 예측을 수행합니다.
+    이동평균, 추세, 기술적 지표를 기반으로 향후 가격 방향을 예측합니다.
+    
+    Args:
+        symbol: 예측할 종목 티커
+        end_date: 예측 시작 날짜
+        forecast_days: 예측 기간 (일)
+        include_features: 포함할 추가 특성
+    
+    Returns:
+        예측 결과 및 분석 문자열
+    """
+    try:
+        end_dt = pd.to_datetime(end_date)
+        start_dt = end_dt - timedelta(days=365)
+        start_date = start_dt.strftime("%Y-%m-%d")
+        
+        # 주가 데이터
+        stock_data = yf.download(symbol, start=start_date, end=end_date, progress=False)
+        if stock_data.empty:
+            return f"No data found for {symbol}"
+        
+        # MultiIndex columns 처리
+        if isinstance(stock_data.columns, pd.MultiIndex):
+            stock_data.columns = stock_data.columns.get_level_values(0)
+        
+        close = stock_data["Close"]
+        
+        # 기술적 지표 계산
+        sma_20 = close.rolling(20).mean()
+        sma_50 = close.rolling(50).mean()
+        sma_200 = close.rolling(200).mean()
+        
+        # RSI
+        delta = close.diff()
+        gain = delta.where(delta > 0, 0).rolling(14).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+        rs = gain / loss
+        rsi = 100 - (100 / (1 + rs))
+        
+        # 변동성
+        volatility = close.pct_change().rolling(20).std() * np.sqrt(252) * 100
+        
+        # 추세 분석 - .iloc[0] 사용하여 스칼라 추출
+        current_price = float(close.iloc[-1].iloc[0]) if hasattr(close.iloc[-1], 'iloc') else float(close.iloc[-1])
+        current_sma20 = float(sma_20.iloc[-1].iloc[0]) if hasattr(sma_20.iloc[-1], 'iloc') else float(sma_20.iloc[-1])
+        current_sma50 = float(sma_50.iloc[-1].iloc[0]) if hasattr(sma_50.iloc[-1], 'iloc') else float(sma_50.iloc[-1])
+        
+        if len(sma_200.dropna()) > 0:
+            current_sma200 = float(sma_200.iloc[-1].iloc[0]) if hasattr(sma_200.iloc[-1], 'iloc') else float(sma_200.iloc[-1])
+        else:
+            current_sma200 = current_price
+            
+        current_rsi = float(rsi.iloc[-1].iloc[0]) if hasattr(rsi.iloc[-1], 'iloc') else float(rsi.iloc[-1])
+        current_vol = float(volatility.iloc[-1].iloc[0]) if hasattr(volatility.iloc[-1], 'iloc') else float(volatility.iloc[-1])
+        
+        # 추세 점수 계산
+        trend_score = 0
+        signals = []
+        
+        # SMA 기반 신호
+        if current_price > current_sma20:
+            trend_score += 1
+            signals.append("Price above SMA20 (short-term bullish)")
+        else:
+            trend_score -= 1
+            signals.append("Price below SMA20 (short-term bearish)")
+        
+        if current_price > current_sma50:
+            trend_score += 1
+            signals.append("Price above SMA50 (medium-term bullish)")
+        else:
+            trend_score -= 1
+            signals.append("Price below SMA50 (medium-term bearish)")
+        
+        if current_price > current_sma200:
+            trend_score += 2
+            signals.append("Price above SMA200 (long-term bullish)")
+        else:
+            trend_score -= 2
+            signals.append("Price below SMA200 (long-term bearish)")
+        
+        # RSI 기반 신호
+        if current_rsi > 70:
+            trend_score -= 1
+            signals.append(f"RSI={current_rsi:.1f} (Overbought - potential reversal)")
+        elif current_rsi < 30:
+            trend_score += 1
+            signals.append(f"RSI={current_rsi:.1f} (Oversold - potential bounce)")
+        else:
+            signals.append(f"RSI={current_rsi:.1f} (Neutral)")
+        
+        # Golden/Death Cross 확인
+        if len(sma_50) > 5 and len(sma_200.dropna()) > 5:
+            recent_cross = sma_50.iloc[-5:] - sma_200.iloc[-5:]
+            # Series에서 스칼라 값 추출
+            last_cross = float(recent_cross.iloc[-1].iloc[0]) if hasattr(recent_cross.iloc[-1], 'iloc') else float(recent_cross.iloc[-1])
+            first_cross = float(recent_cross.iloc[0].iloc[0]) if hasattr(recent_cross.iloc[0], 'iloc') else float(recent_cross.iloc[0])
+            if last_cross > 0 and first_cross < 0:
+                trend_score += 2
+                signals.append("🔥 Golden Cross detected (Very Bullish)")
+            elif last_cross < 0 and first_cross > 0:
+                trend_score -= 2
+                signals.append("💀 Death Cross detected (Very Bearish)")
+        
+        # 모멘텀 계산
+        price_22 = float(close.iloc[-22].iloc[0]) if hasattr(close.iloc[-22], 'iloc') else float(close.iloc[-22])
+        price_66 = float(close.iloc[-66].iloc[0]) if hasattr(close.iloc[-66], 'iloc') else float(close.iloc[-66])
+        momentum_1m = (current_price / price_22 - 1) * 100 if len(close) > 22 else 0
+        momentum_3m = (current_price / price_66 - 1) * 100 if len(close) > 66 else 0
+        
+        # 예측 방향 결정
+        if trend_score >= 3:
+            direction = "BULLISH"
+            confidence = "High"
+            emoji = "🚀"
+        elif trend_score >= 1:
+            direction = "SLIGHTLY BULLISH"
+            confidence = "Moderate"
+            emoji = "📈"
+        elif trend_score <= -3:
+            direction = "BEARISH"
+            confidence = "High"
+            emoji = "📉"
+        elif trend_score <= -1:
+            direction = "SLIGHTLY BEARISH"
+            confidence = "Moderate"
+            emoji = "🔻"
+        else:
+            direction = "NEUTRAL"
+            confidence = "Low"
+            emoji = "➡️"
+        
+        # 가격 목표 계산 (간단한 추정)
+        avg_daily_return = float(close.pct_change().tail(60).mean())
+        expected_return = avg_daily_return * forecast_days
+        
+        if trend_score > 0:
+            target_price = current_price * (1 + abs(expected_return) * (1 + trend_score/5))
+        elif trend_score < 0:
+            target_price = current_price * (1 - abs(expected_return) * (1 + abs(trend_score)/5))
+        else:
+            target_price = current_price * (1 + expected_return)
+        
+        # 결과 생성
+        result = f"# Time Series Forecast: {symbol}\n"
+        result += f"Analysis Date: {end_date}\n"
+        result += f"Forecast Period: {forecast_days} days\n\n"
+        
+        result += "## Current Status\n"
+        result += f"- **Current Price**: ${current_price:.2f}\n"
+        result += f"- **20-day SMA**: ${current_sma20:.2f}\n"
+        result += f"- **50-day SMA**: ${current_sma50:.2f}\n"
+        result += f"- **200-day SMA**: ${current_sma200:.2f}\n"
+        result += f"- **RSI (14)**: {current_rsi:.1f}\n"
+        result += f"- **Volatility (Ann.)**: {current_vol:.1f}%\n\n"
+        
+        result += "## Momentum\n"
+        result += f"- **1-Month Return**: {momentum_1m:+.2f}%\n"
+        result += f"- **3-Month Return**: {momentum_3m:+.2f}%\n\n"
+        
+        result += "## Technical Signals\n"
+        for signal in signals:
+            result += f"- {signal}\n"
+        
+        result += f"\n## Forecast Result {emoji}\n"
+        result += f"- **Direction**: {direction}\n"
+        result += f"- **Confidence**: {confidence}\n"
+        result += f"- **Trend Score**: {trend_score:+d} (range: -6 to +6)\n"
+        result += f"- **Price Target ({forecast_days}d)**: ${target_price:.2f} ({((target_price/current_price)-1)*100:+.2f}%)\n"
+        
+        result += f"\n## Risk Assessment\n"
+        result += f"- **Annualized Volatility**: {current_vol:.1f}%\n"
+        result += f"- **Expected {forecast_days}d Range**: ${current_price * (1 - current_vol/100 * np.sqrt(forecast_days/252)):.2f} - ${current_price * (1 + current_vol/100 * np.sqrt(forecast_days/252)):.2f}\n"
+        
+        result += f"\n⚠️ *This is a simplified technical analysis forecast. Not financial advice.*\n"
+        
+        return result
+    
+    except Exception as e:
+        return f"Error running forecast: {str(e)}"
+
+
+@tool
+def collect_forecast_features(
+    symbol: Annotated[str, "The stock ticker symbol"],
+    end_date: Annotated[str, "The end date, YYYY-MM-DD format"],
+    lookback_days: Annotated[int, "Days of historical data to collect"] = 365,
+) -> str:
+    """
+    시계열 예측을 위한 모든 특성 데이터를 수집합니다.
+    주가, 거시경제 지표, 섹터 데이터를 통합하여 예측 모델에 사용할 수 있는 데이터셋을 생성합니다.
+    
+    Args:
+        symbol: 대상 종목 티커
+        end_date: 기준 날짜
+        lookback_days: 과거 데이터 기간
+    
+    Returns:
+        수집된 특성 데이터 요약
+    """
+    try:
+        end_dt = pd.to_datetime(end_date)
+        start_dt = end_dt - timedelta(days=lookback_days)
+        start_date = start_dt.strftime("%Y-%m-%d")
+        
+        # 1. 주가 데이터
+        stock_data = yf.download(symbol, start=start_date, end=end_date, progress=False)
+        if stock_data.empty:
+            return f"No data found for {symbol}"
+        
+        # MultiIndex columns 처리
+        if isinstance(stock_data.columns, pd.MultiIndex):
+            stock_data.columns = stock_data.columns.get_level_values(0)
+        
+        # 2. 거시경제 데이터
+        macro_data = get_all_macro_features(end_date, lookback_days)
+        
+        # 3. 섹터 데이터
+        sector_data = get_related_sector_data(symbol, start_date, end_date)
+        
+        # 데이터 병합
+        result_df = stock_data[["Close", "Volume"]].copy()
+        result_df.columns = [f"{symbol}_close", f"{symbol}_volume"]
+        
+        if not macro_data.empty:
+            result_df = result_df.join(macro_data, how="left")
+        
+        if not sector_data.empty:
+            result_df = result_df.join(sector_data, how="left")
+        
+        result_df = result_df.ffill().bfill().dropna()
+        
+        # 통계 요약
+        result = f"# Feature Collection Summary for {symbol}\n"
+        result += f"Period: {start_date} to {end_date}\n\n"
+        
+        result += "## Collected Features\n"
+        result += f"- **Total Data Points**: {len(result_df)}\n"
+        result += f"- **Number of Features**: {len(result_df.columns)}\n\n"
+        
+        result += "| Feature | Mean | Std | Min | Max |\n"
+        result += "|---------|------|-----|-----|-----|\n"
+        
+        for col in result_df.columns:
+            mean = result_df[col].mean()
+            std = result_df[col].std()
+            min_val = result_df[col].min()
+            max_val = result_df[col].max()
+            result += f"| {col} | {mean:.2f} | {std:.2f} | {min_val:.2f} | {max_val:.2f} |\n"
+        
+        # 상관관계 매트릭스 (주가와의 상관관계)
+        result += "\n## Correlation with Target Price\n"
+        target_col = f"{symbol}_close"
+        correlations = result_df.corr()[target_col].sort_values(ascending=False)
+        
+        result += "| Feature | Correlation |\n"
+        result += "|---------|-------------|\n"
+        for feat, corr in correlations.items():
+            if feat != target_col:
+                result += f"| {feat} | {corr:+.3f} |\n"
+        
+        result += "\n## Data Quality\n"
+        missing = result_df.isnull().sum().sum()
+        result += f"- Missing values after forward fill: {missing}\n"
+        result += f"- Data completeness: {(1 - missing/(len(result_df)*len(result_df.columns)))*100:.1f}%\n"
+        
+        return result
+    
+    except Exception as e:
+        return f"Error collecting features: {str(e)}"
+
+
+# ============================================================================
+# 딥러닝 기반 앙상블 예측 (NeuralForecast)
+# ============================================================================
+
+def _check_neuralforecast_available():
+    """NeuralForecast 라이브러리 가용성 확인"""
+    try:
+        from neuralforecast import NeuralForecast
+        from neuralforecast.models import DLinear, NHITS, NBEATS
+        return True
+    except ImportError:
+        return False
+
+
+class EnsembleForecaster:
+    """메모리 효율적인 딥러닝 앙상블 시계열 예측기"""
+    
+    def __init__(
+        self,
+        input_size: int = 30,
+        horizon: int = 5,
+        batch_size: int = 32,
+        max_steps: int = 100,
+    ):
+        self.input_size = input_size
+        self.horizon = horizon
+        self.batch_size = batch_size
+        self.max_steps = max_steps
+        self.weights = {
+            'DLinear': 0.3,
+            'NHITS': 0.4,
+            'NBEATS': 0.3
+        }
+    
+    def prepare_data(self, symbol: str, end_date: str, lookback_days: int = 365) -> pd.DataFrame:
+        """yfinance에서 데이터를 NeuralForecast 형식으로 변환"""
+        end_dt = pd.to_datetime(end_date)
+        start_dt = end_dt - timedelta(days=lookback_days)
+        
+        ticker = yf.Ticker(symbol)
+        df = ticker.history(start=start_dt.strftime("%Y-%m-%d"), end=end_dt.strftime("%Y-%m-%d"))
+        
+        if df.empty:
+            raise ValueError(f"No data found for {symbol}")
+        
+        nf_df = pd.DataFrame({
+            'unique_id': symbol,
+            'ds': df.index.tz_localize(None),
+            'y': df['Close'].values
+        })
+        
+        return nf_df
+    
+    def _run_single_model(self, model_class, model_name: str, df: pd.DataFrame) -> pd.DataFrame:
+        """단일 모델 실행 후 메모리 해제"""
+        from neuralforecast import NeuralForecast
+        from neuralforecast.models import DLinear, NHITS, NBEATS
+        
+        if model_name == 'DLinear':
+            model = model_class(
+                h=self.horizon,
+                input_size=self.input_size,
+                max_steps=self.max_steps,
+                batch_size=self.batch_size,
+                scaler_type='standard',
+                random_seed=42,
+            )
+        elif model_name == 'NHITS':
+            model = model_class(
+                h=self.horizon,
+                input_size=self.input_size,
+                max_steps=self.max_steps,
+                batch_size=self.batch_size,
+                n_pool_kernel_size=[2, 2, 1],
+                n_freq_downsample=[4, 2, 1],
+                scaler_type='standard',
+                random_seed=42,
+            )
+        elif model_name == 'NBEATS':
+            model = model_class(
+                h=self.horizon,
+                input_size=self.input_size,
+                max_steps=self.max_steps,
+                batch_size=self.batch_size,
+                scaler_type='standard',
+                random_seed=42,
+            )
+        
+        nf = NeuralForecast(models=[model], freq='B')
+        nf.fit(df=df)
+        forecast = nf.predict()
+        
+        del nf, model
+        gc.collect()
+        
+        return forecast
+    
+    def forecast(self, symbol: str, end_date: str, lookback_days: int = 365,
+                 use_single_model: bool = True) -> dict:
+        """앙상블 예측 실행
+
+        Args:
+            use_single_model: True면 DLinear만 사용 (빠름, 2초), False면 3개 모델 사용 (8초)
+        """
+        from neuralforecast.models import DLinear, NHITS, NBEATS
+
+        df = self.prepare_data(symbol, end_date, lookback_days)
+
+        # 최적화: DLinear만 사용 (논문에 따르면 복잡한 모델과 비슷하거나 더 나은 성능)
+        if use_single_model:
+            models_to_run = [
+                (DLinear, 'DLinear'),
+            ]
+        else:
+            models_to_run = [
+                (DLinear, 'DLinear'),
+                (NHITS, 'NHITS'),
+                (NBEATS, 'NBEATS'),
+            ]
+        
+        forecasts = {}
+        for model_class, model_name in models_to_run:
+            try:
+                forecast = self._run_single_model(model_class, model_name, df)
+                forecasts[model_name] = forecast
+            except Exception as e:
+                continue
+        
+        # 앙상블 결합
+        ensemble_pred = None
+        total_weight = 0
+        
+        for model_name, forecast in forecasts.items():
+            pred_col = model_name
+            if pred_col in forecast.columns:
+                weight = self.weights.get(model_name, 0.33)
+                if ensemble_pred is None:
+                    ensemble_pred = forecast[pred_col].values * weight
+                else:
+                    ensemble_pred += forecast[pred_col].values * weight
+                total_weight += weight
+        
+        if ensemble_pred is not None and total_weight > 0:
+            ensemble_pred = ensemble_pred / total_weight
+        
+        current_price = df['y'].iloc[-1]
+        
+        # 각 모델별 예측 요약
+        model_predictions = {}
+        for model_name, forecast in forecasts.items():
+            pred_col = model_name
+            if pred_col in forecast.columns:
+                preds = forecast[pred_col].values
+                model_predictions[model_name] = {
+                    'predictions': preds.tolist(),
+                    'final_price': float(preds[-1]),
+                    'change_pct': float((preds[-1] / current_price - 1) * 100)
+                }
+        
+        # 결과 생성
+        result = {
+            'symbol': symbol,
+            'current_price': float(current_price),
+            'forecast_dates': self._get_forecast_dates(end_date),
+            'ensemble_predictions': ensemble_pred.tolist() if ensemble_pred is not None else [],
+            'ensemble_final_price': float(ensemble_pred[-1]) if ensemble_pred is not None else current_price,
+            'ensemble_change_pct': float((ensemble_pred[-1] / current_price - 1) * 100) if ensemble_pred is not None else 0,
+            'model_predictions': model_predictions,
+            'signal': self._generate_signal(ensemble_pred, current_price),
+            'confidence': self._calculate_confidence(model_predictions),
+        }
+        
+        return result
+    
+    def _get_forecast_dates(self, end_date: str) -> list:
+        end_dt = pd.to_datetime(end_date)
+        dates = pd.bdate_range(start=end_dt + timedelta(days=1), periods=self.horizon)
+        return [d.strftime('%Y-%m-%d') for d in dates]
+    
+    def _generate_signal(self, predictions: np.ndarray, current_price: float) -> dict:
+        if predictions is None or len(predictions) == 0:
+            return {'action': 'HOLD', 'strength': 0, 'reason': 'No valid predictions'}
+        
+        final_pred = predictions[-1]
+        change_pct = (final_pred / current_price - 1) * 100
+        trend_direction = np.mean(np.diff(predictions))
+        
+        if change_pct > 3:
+            action = 'STRONG_BUY'
+            strength = min(100, int(change_pct * 10))
+        elif change_pct > 1:
+            action = 'BUY'
+            strength = min(80, int(change_pct * 15))
+        elif change_pct < -3:
+            action = 'STRONG_SELL'
+            strength = min(100, int(abs(change_pct) * 10))
+        elif change_pct < -1:
+            action = 'SELL'
+            strength = min(80, int(abs(change_pct) * 15))
+        else:
+            action = 'HOLD'
+            strength = 50
+        
+        return {
+            'action': action,
+            'strength': strength,
+            'expected_change_pct': round(change_pct, 2),
+            'trend': 'UPWARD' if trend_direction > 0 else 'DOWNWARD' if trend_direction < 0 else 'SIDEWAYS',
+            'reason': f"Ensemble predicts {change_pct:+.2f}% change over {self.horizon} days"
+        }
+    
+    def _calculate_confidence(self, model_predictions: dict) -> dict:
+        if not model_predictions:
+            return {'score': 0, 'agreement': 'NONE'}
+        
+        changes = [p['change_pct'] for p in model_predictions.values()]
+        
+        if len(changes) < 2:
+            return {'score': 50, 'agreement': 'SINGLE_MODEL'}
+        
+        std = np.std(changes)
+        all_positive = all(c > 0 for c in changes)
+        all_negative = all(c < 0 for c in changes)
+        direction_agreement = all_positive or all_negative
+        
+        if std < 0.5 and direction_agreement:
+            score = 90
+            agreement = 'VERY_HIGH'
+        elif std < 1.0 and direction_agreement:
+            score = 75
+            agreement = 'HIGH'
+        elif direction_agreement:
+            score = 60
+            agreement = 'MODERATE'
+        else:
+            score = 40
+            agreement = 'LOW'
+        
+        return {
+            'score': score,
+            'agreement': agreement,
+            'std_deviation': round(std, 2),
+            'direction_aligned': direction_agreement
+        }
+
+
+@tool
+def run_ensemble_forecast(
+    symbol: Annotated[str, "The stock ticker symbol to forecast"],
+    end_date: Annotated[str, "The forecast start date, YYYY-MM-DD format"],
+    forecast_days: Annotated[int, "Number of days to forecast (default: 5)"] = 5,
+    input_size: Annotated[int, "Number of historical days to use as input (default: 30)"] = 30,
+    use_single_model: Annotated[bool, "Use only DLinear for faster prediction (default: True)"] = True,
+) -> str:
+    """
+    딥러닝 모델을 사용한 시계열 예측을 수��합니다.
+    기본값: DLinear 단일 모델 사용 (빠름, ~2초)
+    use_single_model=False: 3개 모델 앙상블 (느림, ~8초)
+
+    모델 설명:
+    - DLinear: 선형 분해 기반 경량 모델 (빠르고 안정적, 논문에서 SOTA급 성능)
+    - NHITS: 계층적 시간 인터폴레이션 (장기 패턴 포착)
+    - NBEATS: 신경망 기반 분해 (높은 정확도)
+
+    Args:
+        symbol: 예측할 종목 티커
+        end_date: 예측 시작 날짜
+        forecast_days: 예측 기간 (일)
+        input_size: 입력 시퀀스 길이 (일)
+        use_single_model: True면 DLinear만 사용 (권장)
+
+    Returns:
+        예측 결과 문자열
+    """
+    # NeuralForecast 가용성 확인
+    if not _check_neuralforecast_available():
+        return "NeuralForecast library not available. Please install: pip install neuralforecast scipy"
+
+    try:
+        forecaster = EnsembleForecaster(
+            input_size=input_size,
+            horizon=forecast_days,
+            batch_size=32,
+            max_steps=100,
+        )
+
+        result = forecaster.forecast(symbol, end_date, lookback_days=365,
+                                    use_single_model=use_single_model)
+        
+        # 포맷팅된 결과 생성
+        report = []
+        report.append(f"# Deep Learning Ensemble Forecast: {result['symbol']}")
+        report.append(f"Models: DLinear (30%) + NHITS (40%) + NBEATS (30%)\n")
+        
+        report.append(f"## Current Status")
+        report.append(f"- **Current Price**: ${result['current_price']:.2f}")
+        
+        report.append(f"\n## Ensemble Prediction ({forecast_days}-Day Forecast)")
+        report.append(f"- **Predicted Price**: ${result['ensemble_final_price']:.2f}")
+        report.append(f"- **Expected Change**: {result['ensemble_change_pct']:+.2f}%")
+        
+        report.append(f"\n## Daily Predictions")
+        for i, (date, pred) in enumerate(zip(result['forecast_dates'], result['ensemble_predictions'])):
+            change = (pred / result['current_price'] - 1) * 100
+            report.append(f"  Day {i+1} ({date}): ${pred:.2f} ({change:+.2f}%)")
+        
+        report.append(f"\n## Individual Model Predictions")
+        for model_name, pred in result['model_predictions'].items():
+            report.append(f"  - {model_name}: ${pred['final_price']:.2f} ({pred['change_pct']:+.2f}%)")
+        
+        signal = result['signal']
+        report.append(f"\n## Trading Signal")
+        report.append(f"  - **Action**: {signal['action']}")
+        report.append(f"  - **Strength**: {signal['strength']}/100")
+        report.append(f"  - **Trend**: {signal['trend']}")
+        report.append(f"  - **Reason**: {signal['reason']}")
+        
+        conf = result['confidence']
+        report.append(f"\n## Model Confidence")
+        report.append(f"  - **Score**: {conf['score']}/100")
+        report.append(f"  - **Agreement**: {conf['agreement']}")
+        if 'direction_aligned' in conf:
+            report.append(f"  - **Direction Aligned**: {'Yes ✓' if conf['direction_aligned'] else 'No ✗'}")
+        
+        report.append(f"\n⚠️ *Deep learning forecast. Not financial advice.*")
+        
+        return '\n'.join(report)
+        
+    except Exception as e:
+        return f"Error running ensemble forecast: {str(e)}"
+
+
+# 도구 목록 (에이전트에서 사용)
+TIMESERIES_TOOLS = [
+    get_macro_indicators,
+    get_sector_performance,
+    get_correlated_assets,
+    analyze_stock_for_forecasting,
+    run_simple_forecast,
+    collect_forecast_features,
+    run_ensemble_forecast,  # 새로운 딥러닝 앙상블 도구
+]

tradingagents/dataflows/alpha_vantage.py

@@ -0,0 +1,5 @@
+# Import functions from specialized modules
+from .alpha_vantage_stock import get_stock
+from .alpha_vantage_indicator import get_indicator
+from .alpha_vantage_fundamentals import get_fundamentals, get_balance_sheet, get_cashflow, get_income_statement
+from .alpha_vantage_news import get_news, get_insider_transactions

tradingagents/dataflows/alpha_vantage_common.py

@@ -0,0 +1,122 @@
+import os
+import requests
+import pandas as pd
+import json
+from datetime import datetime
+from io import StringIO
+
+API_BASE_URL = "https://www.alphavantage.co/query"
+
+def get_api_key() -> str:
+    """Retrieve the API key for Alpha Vantage from environment variables."""
+    api_key = os.getenv("ALPHA_VANTAGE_API_KEY")
+    if not api_key:
+        raise ValueError("ALPHA_VANTAGE_API_KEY environment variable is not set.")
+    return api_key
+
+def format_datetime_for_api(date_input) -> str:
+    """Convert various date formats to YYYYMMDDTHHMM format required by Alpha Vantage API."""
+    if isinstance(date_input, str):
+        # If already in correct format, return as-is
+        if len(date_input) == 13 and 'T' in date_input:
+            return date_input
+        # Try to parse common date formats
+        try:
+            dt = datetime.strptime(date_input, "%Y-%m-%d")
+            return dt.strftime("%Y%m%dT0000")
+        except ValueError:
+            try:
+                dt = datetime.strptime(date_input, "%Y-%m-%d %H:%M")
+                return dt.strftime("%Y%m%dT%H%M")
+            except ValueError:
+                raise ValueError(f"Unsupported date format: {date_input}")
+    elif isinstance(date_input, datetime):
+        return date_input.strftime("%Y%m%dT%H%M")
+    else:
+        raise ValueError(f"Date must be string or datetime object, got {type(date_input)}")
+
+class AlphaVantageRateLimitError(Exception):
+    """Exception raised when Alpha Vantage API rate limit is exceeded."""
+    pass
+
+def _make_api_request(function_name: str, params: dict) -> dict | str:
+    """Helper function to make API requests and handle responses.
+    
+    Raises:
+        AlphaVantageRateLimitError: When API rate limit is exceeded
+    """
+    # Create a copy of params to avoid modifying the original
+    api_params = params.copy()
+    api_params.update({
+        "function": function_name,
+        "apikey": get_api_key(),
+        "source": "trading_agents",
+    })
+    
+    # Handle entitlement parameter if present in params or global variable
+    current_entitlement = globals().get('_current_entitlement')
+    entitlement = api_params.get("entitlement") or current_entitlement
+    
+    if entitlement:
+        api_params["entitlement"] = entitlement
+    elif "entitlement" in api_params:
+        # Remove entitlement if it's None or empty
+        api_params.pop("entitlement", None)
+    
+    response = requests.get(API_BASE_URL, params=api_params)
+    response.raise_for_status()
+
+    response_text = response.text
+    
+    # Check if response is JSON (error responses are typically JSON)
+    try:
+        response_json = json.loads(response_text)
+        # Check for rate limit error
+        if "Information" in response_json:
+            info_message = response_json["Information"]
+            if "rate limit" in info_message.lower() or "api key" in info_message.lower():
+                raise AlphaVantageRateLimitError(f"Alpha Vantage rate limit exceeded: {info_message}")
+    except json.JSONDecodeError:
+        # Response is not JSON (likely CSV data), which is normal
+        pass
+
+    return response_text
+
+
+
+def _filter_csv_by_date_range(csv_data: str, start_date: str, end_date: str) -> str:
+    """
+    Filter CSV data to include only rows within the specified date range.
+
+    Args:
+        csv_data: CSV string from Alpha Vantage API
+        start_date: Start date in yyyy-mm-dd format
+        end_date: End date in yyyy-mm-dd format
+
+    Returns:
+        Filtered CSV string
+    """
+    if not csv_data or csv_data.strip() == "":
+        return csv_data
+
+    try:
+        # Parse CSV data
+        df = pd.read_csv(StringIO(csv_data))
+
+        # Assume the first column is the date column (timestamp)
+        date_col = df.columns[0]
+        df[date_col] = pd.to_datetime(df[date_col])
+
+        # Filter by date range
+        start_dt = pd.to_datetime(start_date)
+        end_dt = pd.to_datetime(end_date)
+
+        filtered_df = df[(df[date_col] >= start_dt) & (df[date_col] <= end_dt)]
+
+        # Convert back to CSV string
+        return filtered_df.to_csv(index=False)
+
+    except Exception as e:
+        # If filtering fails, return original data with a warning
+        print(f"Warning: Failed to filter CSV data by date range: {e}")
+        return csv_data

tradingagents/dataflows/alpha_vantage_fundamentals.py

@@ -0,0 +1,77 @@
+from .alpha_vantage_common import _make_api_request
+
+
+def get_fundamentals(ticker: str, curr_date: str = None) -> str:
+    """
+    Retrieve comprehensive fundamental data for a given ticker symbol using Alpha Vantage.
+
+    Args:
+        ticker (str): Ticker symbol of the company
+        curr_date (str): Current date you are trading at, yyyy-mm-dd (not used for Alpha Vantage)
+
+    Returns:
+        str: Company overview data including financial ratios and key metrics
+    """
+    params = {
+        "symbol": ticker,
+    }
+
+    return _make_api_request("OVERVIEW", params)
+
+
+def get_balance_sheet(ticker: str, freq: str = "quarterly", curr_date: str = None) -> str:
+    """
+    Retrieve balance sheet data for a given ticker symbol using Alpha Vantage.
+
+    Args:
+        ticker (str): Ticker symbol of the company
+        freq (str): Reporting frequency: annual/quarterly (default quarterly) - not used for Alpha Vantage
+        curr_date (str): Current date you are trading at, yyyy-mm-dd (not used for Alpha Vantage)
+
+    Returns:
+        str: Balance sheet data with normalized fields
+    """
+    params = {
+        "symbol": ticker,
+    }
+
+    return _make_api_request("BALANCE_SHEET", params)
+
+
+def get_cashflow(ticker: str, freq: str = "quarterly", curr_date: str = None) -> str:
+    """
+    Retrieve cash flow statement data for a given ticker symbol using Alpha Vantage.
+
+    Args:
+        ticker (str): Ticker symbol of the company
+        freq (str): Reporting frequency: annual/quarterly (default quarterly) - not used for Alpha Vantage
+        curr_date (str): Current date you are trading at, yyyy-mm-dd (not used for Alpha Vantage)
+
+    Returns:
+        str: Cash flow statement data with normalized fields
+    """
+    params = {
+        "symbol": ticker,
+    }
+
+    return _make_api_request("CASH_FLOW", params)
+
+
+def get_income_statement(ticker: str, freq: str = "quarterly", curr_date: str = None) -> str:
+    """
+    Retrieve income statement data for a given ticker symbol using Alpha Vantage.
+
+    Args:
+        ticker (str): Ticker symbol of the company
+        freq (str): Reporting frequency: annual/quarterly (default quarterly) - not used for Alpha Vantage
+        curr_date (str): Current date you are trading at, yyyy-mm-dd (not used for Alpha Vantage)
+
+    Returns:
+        str: Income statement data with normalized fields
+    """
+    params = {
+        "symbol": ticker,
+    }
+
+    return _make_api_request("INCOME_STATEMENT", params)
+

tradingagents/dataflows/alpha_vantage_indicator.py

@@ -0,0 +1,222 @@
+from .alpha_vantage_common import _make_api_request
+
+def get_indicator(
+    symbol: str,
+    indicator: str,
+    curr_date: str,
+    look_back_days: int,
+    interval: str = "daily",
+    time_period: int = 14,
+    series_type: str = "close"
+) -> str:
+    """
+    Returns Alpha Vantage technical indicator values over a time window.
+
+    Args:
+        symbol: ticker symbol of the company
+        indicator: technical indicator to get the analysis and report of
+        curr_date: The current trading date you are trading on, YYYY-mm-dd
+        look_back_days: how many days to look back
+        interval: Time interval (daily, weekly, monthly)
+        time_period: Number of data points for calculation
+        series_type: The desired price type (close, open, high, low)
+
+    Returns:
+        String containing indicator values and description
+    """
+    from datetime import datetime
+    from dateutil.relativedelta import relativedelta
+
+    supported_indicators = {
+        "close_50_sma": ("50 SMA", "close"),
+        "close_200_sma": ("200 SMA", "close"),
+        "close_10_ema": ("10 EMA", "close"),
+        "macd": ("MACD", "close"),
+        "macds": ("MACD Signal", "close"),
+        "macdh": ("MACD Histogram", "close"),
+        "rsi": ("RSI", "close"),
+        "boll": ("Bollinger Middle", "close"),
+        "boll_ub": ("Bollinger Upper Band", "close"),
+        "boll_lb": ("Bollinger Lower Band", "close"),
+        "atr": ("ATR", None),
+        "vwma": ("VWMA", "close")
+    }
+
+    indicator_descriptions = {
+        "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": "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.",
+        "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.",
+        "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.",
+        "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."
+    }
+
+    if indicator not in supported_indicators:
+        raise ValueError(
+            f"Indicator {indicator} is not supported. Please choose from: {list(supported_indicators.keys())}"
+        )
+
+    curr_date_dt = datetime.strptime(curr_date, "%Y-%m-%d")
+    before = curr_date_dt - relativedelta(days=look_back_days)
+
+    # Get the full data for the period instead of making individual calls
+    _, required_series_type = supported_indicators[indicator]
+
+    # Use the provided series_type or fall back to the required one
+    if required_series_type:
+        series_type = required_series_type
+
+    try:
+        # Get indicator data for the period
+        if indicator == "close_50_sma":
+            data = _make_api_request("SMA", {
+                "symbol": symbol,
+                "interval": interval,
+                "time_period": "50",
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "close_200_sma":
+            data = _make_api_request("SMA", {
+                "symbol": symbol,
+                "interval": interval,
+                "time_period": "200",
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "close_10_ema":
+            data = _make_api_request("EMA", {
+                "symbol": symbol,
+                "interval": interval,
+                "time_period": "10",
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "macd":
+            data = _make_api_request("MACD", {
+                "symbol": symbol,
+                "interval": interval,
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "macds":
+            data = _make_api_request("MACD", {
+                "symbol": symbol,
+                "interval": interval,
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "macdh":
+            data = _make_api_request("MACD", {
+                "symbol": symbol,
+                "interval": interval,
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "rsi":
+            data = _make_api_request("RSI", {
+                "symbol": symbol,
+                "interval": interval,
+                "time_period": str(time_period),
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator in ["boll", "boll_ub", "boll_lb"]:
+            data = _make_api_request("BBANDS", {
+                "symbol": symbol,
+                "interval": interval,
+                "time_period": "20",
+                "series_type": series_type,
+                "datatype": "csv"
+            })
+        elif indicator == "atr":
+            data = _make_api_request("ATR", {
+                "symbol": symbol,
+                "interval": interval,
+                "time_period": str(time_period),
+                "datatype": "csv"
+            })
+        elif indicator == "vwma":
+            # Alpha Vantage doesn't have direct VWMA, so we'll return an informative message
+            # In a real implementation, this would need to be calculated from OHLCV data
+            return f"## VWMA (Volume Weighted Moving Average) for {symbol}:\n\nVWMA calculation requires OHLCV data and is not directly available from Alpha Vantage API.\nThis indicator would need to be calculated from the raw stock data using volume-weighted price averaging.\n\n{indicator_descriptions.get('vwma', 'No description available.')}"
+        else:
+            return f"Error: Indicator {indicator} not implemented yet."
+
+        # Parse CSV data and extract values for the date range
+        lines = data.strip().split('\n')
+        if len(lines) < 2:
+            return f"Error: No data returned for {indicator}"
+
+        # Parse header and data
+        header = [col.strip() for col in lines[0].split(',')]
+        try:
+            date_col_idx = header.index('time')
+        except ValueError:
+            return f"Error: 'time' column not found in data for {indicator}. Available columns: {header}"
+
+        # Map internal indicator names to expected CSV column names from Alpha Vantage
+        col_name_map = {
+            "macd": "MACD", "macds": "MACD_Signal", "macdh": "MACD_Hist",
+            "boll": "Real Middle Band", "boll_ub": "Real Upper Band", "boll_lb": "Real Lower Band",
+            "rsi": "RSI", "atr": "ATR", "close_10_ema": "EMA",
+            "close_50_sma": "SMA", "close_200_sma": "SMA"
+        }
+
+        target_col_name = col_name_map.get(indicator)
+
+        if not target_col_name:
+            # Default to the second column if no specific mapping exists
+            value_col_idx = 1
+        else:
+            try:
+                value_col_idx = header.index(target_col_name)
+            except ValueError:
+                return f"Error: Column '{target_col_name}' not found for indicator '{indicator}'. Available columns: {header}"
+
+        result_data = []
+        for line in lines[1:]:
+            if not line.strip():
+                continue
+            values = line.split(',')
+            if len(values) > value_col_idx:
+                try:
+                    date_str = values[date_col_idx].strip()
+                    # Parse the date
+                    date_dt = datetime.strptime(date_str, "%Y-%m-%d")
+
+                    # Check if date is in our range
+                    if before <= date_dt <= curr_date_dt:
+                        value = values[value_col_idx].strip()
+                        result_data.append((date_dt, value))
+                except (ValueError, IndexError):
+                    continue
+
+        # Sort by date and format output
+        result_data.sort(key=lambda x: x[0])
+
+        ind_string = ""
+        for date_dt, value in result_data:
+            ind_string += f"{date_dt.strftime('%Y-%m-%d')}: {value}\n"
+
+        if not ind_string:
+            ind_string = "No data available for the specified date range.\n"
+
+        result_str = (
+            f"## {indicator.upper()} values from {before.strftime('%Y-%m-%d')} to {curr_date}:\n\n"
+            + ind_string
+            + "\n\n"
+            + indicator_descriptions.get(indicator, "No description available.")
+        )
+
+        return result_str
+
+    except Exception as e:
+        print(f"Error getting Alpha Vantage indicator data for {indicator}: {e}")
+        return f"Error retrieving {indicator} data: {str(e)}"

tradingagents/dataflows/alpha_vantage_news.py

@@ -0,0 +1,43 @@
+from .alpha_vantage_common import _make_api_request, format_datetime_for_api
+
+def get_news(ticker, start_date, end_date) -> dict[str, str] | str:
+    """Returns live and historical market news & sentiment data from premier news outlets worldwide.
+
+    Covers stocks, cryptocurrencies, forex, and topics like fiscal policy, mergers & acquisitions, IPOs.
+
+    Args:
+        ticker: Stock symbol for news articles.
+        start_date: Start date for news search.
+        end_date: End date for news search.
+
+    Returns:
+        Dictionary containing news sentiment data or JSON string.
+    """
+
+    params = {
+        "tickers": ticker,
+        "time_from": format_datetime_for_api(start_date),
+        "time_to": format_datetime_for_api(end_date),
+        "sort": "LATEST",
+        "limit": "50",
+    }
+    
+    return _make_api_request("NEWS_SENTIMENT", params)
+
+def get_insider_transactions(symbol: str) -> dict[str, str] | str:
+    """Returns latest and historical insider transactions by key stakeholders.
+
+    Covers transactions by founders, executives, board members, etc.
+
+    Args:
+        symbol: Ticker symbol. Example: "IBM".
+
+    Returns:
+        Dictionary containing insider transaction data or JSON string.
+    """
+
+    params = {
+        "symbol": symbol,
+    }
+
+    return _make_api_request("INSIDER_TRANSACTIONS", params)

tradingagents/dataflows/alpha_vantage_stock.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+from .alpha_vantage_common import _make_api_request, _filter_csv_by_date_range
+
+def get_stock(
+    symbol: str,
+    start_date: str,
+    end_date: str
+) -> str:
+    """
+    Returns raw daily OHLCV values, adjusted close values, and historical split/dividend events
+    filtered to the specified date range.
+
+    Args:
+        symbol: The name of the equity. For example: symbol=IBM
+        start_date: Start date in yyyy-mm-dd format
+        end_date: End date in yyyy-mm-dd format
+
+    Returns:
+        CSV string containing the daily adjusted time series data filtered to the date range.
+    """
+    # Parse dates to determine the range
+    start_dt = datetime.strptime(start_date, "%Y-%m-%d")
+    today = datetime.now()
+
+    # Choose outputsize based on whether the requested range is within the latest 100 days
+    # Compact returns latest 100 data points, so check if start_date is recent enough
+    days_from_today_to_start = (today - start_dt).days
+    outputsize = "compact" if days_from_today_to_start < 100 else "full"
+
+    params = {
+        "symbol": symbol,
+        "outputsize": outputsize,
+        "datatype": "csv",
+    }
+
+    response = _make_api_request("TIME_SERIES_DAILY_ADJUSTED", params)
+
+    return _filter_csv_by_date_range(response, start_date, end_date)