dev/web

.gitignore

@@ -8,3 +8,4 @@ eval_data/
 *.egg-info/
 results/
 .env
+tradingagents/dataflows/data_cache/

backend/analysis/application/analysis_service.py

@@ -1,3 +1,8 @@
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '../../..'))
+
+import logging
 from sqlmodel import Session
 from analysis.domain.repository.analysis_repo import IAnalysisRepository
 from ulid import ULID
@@ -9,19 +14,23 @@ from datetime import datetime
 
 from tradingagents.graph.trading_graph import TradingAgentsGraph
 from tradingagents.default_config import DEFAULT_CONFIG
+from analysis.application.websocket_manager import WebSocketManager
+from analysis.infra.db_models.analysis import AnalysisStatus
 
-
+logger = logging.getLogger(__name__)
 
 class AnalysisService:
     def __init__(
         self,
         analysis_repo: IAnalysisRepository,
         session: Session,
-        ulid: ULID
+        ulid: ULID,
+        websocket_manager: WebSocketManager
     ):
         self.analysis_repo = analysis_repo
         self.session = session
         self.ulid = ulid
+        self.websocket_manager = websocket_manager
 
     def get_analysis_list(
         self,
@@ -46,6 +55,15 @@ class AnalysisService:
             
         return analysis
 
+    def get_analysis_sessions_by_member(
+        self,
+        member_id: str
+    ) -> list[AnalysisVO]:
+        analyses = self.analysis_repo.find_by_member_id(member_id)
+        if not analyses:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Analysis not found")
+        return analyses
+
     def create_analysis(
         self,
         member_id: str,
@@ -67,14 +85,20 @@ class AnalysisService:
             backend_url=request.backend_url,
             shallow_thinker=request.shallow_thinker,
             deep_thinker=request.deep_thinker,
-            status="pending",
+            status=AnalysisStatus.PENDING,
             created_at=now,
             updated_at=now
         )
         
         saved_analysis = self.analysis_repo.save(analysis_vo)
+        if not saved_analysis:
+            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to save analysis")
+        
         self.session.commit()
         
+        # Register analysis with websocket manager
+        self.websocket_manager.register_analysis(saved_analysis.id, member_id)
+        
         # 백그라운드에서 분석 실행
         background_tasks.add_task(self._run_analysis, saved_analysis.id)
         
@@ -83,48 +107,58 @@ class AnalysisService:
     async def _run_analysis(self, analysis_id: str):
         """백그라운드에서 실제 분석을 실행하는 메서드"""
         try:
-            # 분석 상태를 RUNNING으로 변경
+            analysis = AnalysisVO(
-            analysis = self.analysis_repo.find_by_id(analysis_id)
+                id=analysis_id,
-            if analysis:
+                status=AnalysisStatus.RUNNING,
-                analysis.status = "running"
+                updated_at=datetime.now()
-                analysis.updated_at = datetime.now()
+            )
-                self.analysis_repo.update(analysis)
-                self.session.commit()
 
-            # 분석 정보 조회
+            analysis = self.analysis_repo.update(analysis)
-            analysis = self.analysis_repo.find_by_id(analysis_id)
             if not analysis:
-                return
+                raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Analysis not found")
+            
+            await self.websocket_manager.send_analysis_update(
+                analysis_id=analysis_id,
+                update_type="status_changed",
+                data={"status": "running", "message": "Analysis started"}
+            )
+            
+            
             
             # TradingAgentsGraph 설정 및 실행
-            config = self._create_config(analysis)
+            if analysis:
+                config = self._create_config(analysis)
             
             # 분석 실행 (실제 구현)
             await self._execute_trading_analysis(analysis_id, analysis, config)
             
-            # 분석 완료 상태로 변경
+            # 완료 상태로 업데이트
-            analysis = self.analysis_repo.find_by_id(analysis_id)
+            completed_analysis = AnalysisVO(
-            if analysis:
+                id=analysis_id,
-                analysis.status = "completed"
+                status=AnalysisStatus.COMPLETED,
-                analysis.completed_at = datetime.now()
+                completed_at=datetime.now(),
-                analysis.updated_at = datetime.now()
+                updated_at=datetime.now()
-                self.analysis_repo.update(analysis)
+            )
-                self.session.commit()
+            self.analysis_repo.update(completed_analysis)
+            self.session.commit()
+            
             
         except Exception as e:
-            # 에러 발생 시 실패 상태로 변경
+            now = datetime.now()
-            analysis = self.analysis_repo.find_by_id(analysis_id)
+            updates = AnalysisVO(
-            if analysis:
+                status=AnalysisStatus.FAILED,
-                analysis.status = "failed"
+                error_message=str(e),
-                analysis.error_message = str(e)
+                completed_at = now,
-                analysis.completed_at = datetime.now()
+                updated_at = now
-                analysis.updated_at = datetime.now()
+            )
-                self.analysis_repo.update(analysis)
+
-                self.session.commit()
+            self.analysis_repo.update(updates)
+            self.session.commit()
+
 
     def _create_config(self, analysis: AnalysisVO) -> dict:
         """분석 설정을 생성하는 메서드"""
-        config = DEFAULT_CONFIG.copy() if DEFAULT_CONFIG else {}
+        config = {}
         config.update({
             "max_debate_rounds": analysis.research_depth,
             "max_risk_discuss_rounds": analysis.research_depth,
@@ -138,12 +172,17 @@ class AnalysisService:
     async def _execute_trading_analysis(self, analysis_id: str, analysis: AnalysisVO, config: dict):
         """실제 TradingAgentsGraph를 실행하는 메서드"""
         try:
+            logger.info(f"Starting trading analysis for {analysis_id} with ticker {analysis.ticker}")
+            logger.info(f"Analysts selected: {analysis.analysts_selected}")
+            logger.info(f"Config: {config}")
+            
             # TradingAgentsGraph 초기화
             graph = TradingAgentsGraph(
                 analysis.analysts_selected,
                 config=config,
                 debug=True
             )
+            logger.info("TradingAgentsGraph initialized successfully")
             
             # 초기 상태 생성
             init_agent_state = graph.propagator.create_initial_state(
@@ -153,8 +192,12 @@ class AnalysisService:
             args = graph.propagator.get_graph_args()
             
             # 분석 실행 및 결과 처리
+            logger.info("Starting graph execution...")
             trace = []
+            chunk_count = 0
             async for chunk in graph.graph.astream(init_agent_state, **args):
+                chunk_count += 1
+                logger.info(f"Processing chunk {chunk_count}: {list(chunk.keys()) if chunk else 'Empty chunk'}")
                 trace.append(chunk)
                 
                 # 실시간으로 분석 결과 업데이트
@@ -167,12 +210,17 @@ class AnalysisService:
                 
                 # 최종 보고서 생성
                 final_report = self._generate_final_report(final_state)
+                analysis.final_trade_decision = final_decision
+                analysis.final_report = final_report
                 
                 # 최종 결과 저장
-                self.analysis_repo.update(analysis_id, {
+                updates = AnalysisVO(
-                    "final_trade_decision": final_decision,
+                    id=analysis_id,
-                    "final_report": final_report
+                    final_trade_decision=final_decision,
-                })
+                    final_report=final_report
+                )
+                self.analysis_repo.update(updates)
+                
                 self.session.commit()
                 
         except Exception as e:
@@ -207,7 +255,10 @@ class AnalysisService:
         
         # 업데이트가 있는 경우 저장
         if updates:
-            self.analysis_repo.update(analysis_id, updates)
+            # analysis_id를 포함한 AnalysisVO 객체 생성
+            updates["id"] = analysis_id
+            updates_vo = AnalysisVO(**updates)
+            self.analysis_repo.update(updates_vo)
             self.session.commit()
 
     def _generate_final_report(self, final_state: dict) -> str:
@@ -245,3 +296,4 @@ class AnalysisService:
             report_parts.append(f"{final_state['risk_debate_state']['judge_decision']}")
         
         return "\n\n".join(report_parts) if report_parts else "No analysis results available."
+

backend/analysis/application/websocket_manager.py

@@ -0,0 +1,65 @@
+from typing import Dict, Set
+from fastapi import WebSocket
+import json
+from datetime import datetime
+
+
+class WebSocketManager:
+    def __init__(self):
+        # Store active connections by member_id
+        self.active_connections: Dict[str, Set[WebSocket]] = {}
+        # Store analysis_id to member_id mapping
+        self.analysis_member_map: Dict[str, str] = {}
+
+    async def connect(self, websocket: WebSocket, member_id: str):
+        await websocket.accept()
+        if member_id not in self.active_connections:
+            self.active_connections[member_id] = set()
+        self.active_connections[member_id].add(websocket)
+
+    def disconnect(self, websocket: WebSocket, member_id: str):
+        if member_id in self.active_connections:
+            self.active_connections[member_id].discard(websocket)
+            if not self.active_connections[member_id]:
+                del self.active_connections[member_id]
+
+    def register_analysis(self, analysis_id: str, member_id: str):
+        """Register which member owns which analysis"""
+        self.analysis_member_map[analysis_id] = member_id
+
+    async def send_analysis_update(self, analysis_id: str, update_type: str, data: dict):
+        """Send analysis update to the member who owns the analysis"""
+        member_id = self.analysis_member_map.get(analysis_id)
+        if not member_id:
+            return
+        
+        message = {
+            "type": "analysis_update",
+            "analysis_id": analysis_id,
+            "update_type": update_type,
+            "data": data,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        await self.send_to_member(member_id, message)
+
+
+
+    async def send_to_member(self, member_id: str, message: dict|str):
+        """Send message to all connections of a specific member"""
+        if member_id not in self.active_connections:
+            return
+        
+        dead_connections = set()
+        for connection in self.active_connections[member_id]:
+            try:
+                if isinstance(message, dict):
+                    await connection.send_json(message)
+                else:
+                    await connection.send_text(message)
+            except Exception:
+                dead_connections.add(connection)
+        
+        # Clean up dead connections
+        for connection in dead_connections:
+            self.disconnect(connection, member_id)

backend/analysis/domain/analysis.py

@@ -1,19 +1,20 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
-from datetime import datetime
+from datetime import datetime, date
-from typing import List, Dict
+from typing import List, Dict, Union
+from analysis.infra.db_models.analysis import AnalysisStatus
 
 class Analysis(BaseModel):
-    id: str | None = None
+    id: str
-    member_id: str
+    member_id: str | None = None
-    ticker: str
+    ticker: str | None = None
-    analysis_date: str
+    analysis_date: date | None = None
-    analysts_selected: List[str] = []
+    analysts_selected: list[str] = []
     research_depth: int = 3
     llm_provider: str = "openai"
     backend_url: str = "https://api.openai.com/v1"
-    shallow_thinker: str = "gpt-4o-mini"
+    shallow_thinker: str = "gpt-4o"
-    deep_thinker: str = "gpt-4o"
+    deep_thinker: str = "o3"
-    status: str
+    status: AnalysisStatus = AnalysisStatus.PENDING
     
     # 개별 분석가 리포트들
     market_report: str | None = None
@@ -33,5 +34,5 @@ class Analysis(BaseModel):
     # 실행 결과 정보
     error_message: str | None = None
     completed_at: datetime | None = None
-    created_at: datetime
+    created_at: datetime | None = None
-    updated_at: datetime
+    updated_at: datetime | None = None

backend/analysis/infra/db_models/analysis.py

@@ -2,7 +2,7 @@ from datetime import datetime,date
 from typing import TYPE_CHECKING
 from sqlmodel import SQLModel, Field, JSON, Relationship
 import enum
-from sqlalchemy import Column
+from sqlalchemy import Column, Text
 
 # TYPE_CHECKING을 사용해서 circular import 방지
 if TYPE_CHECKING:
@@ -32,22 +32,22 @@ class Analysis(SQLModel, table=True):
     status: AnalysisStatus = Field(default=AnalysisStatus.PENDING)
     
     # 개별 분석가 리포트들
-    market_report: str | None = Field(default=None, description="Market Analyst 리포트")
+    market_report: str | None = Field(default=None, sa_column=Column(Text), description="Market Analyst 리포트")
-    sentiment_report: str | None = Field(default=None, description="Social Analyst 리포트") 
+    sentiment_report: str | None = Field(default=None, sa_column=Column(Text), description="Social Analyst 리포트")
-    news_report: str | None = Field(default=None, description="News Analyst 리포트")
+    news_report: str | None = Field(default=None, sa_column=Column(Text), description="News Analyst 리포트")
-    fundamentals_report: str | None = Field(default=None, description="Fundamentals Analyst 리포트")
+    fundamentals_report: str | None = Field(default=None, sa_column=Column(Text), description="Fundamentals Analyst 리포트")
     
     # 팀별 의사결정 과정
     investment_debate_state: dict | None = Field(default=None, sa_column=Column(JSON), description="Research Team 토론 과정")
-    trader_investment_plan: str | None = Field(default=None, description="Trading Team 계획")
+    trader_investment_plan: str | None = Field(default=None, sa_column=Column(Text), description="Trading Team 계획")
     risk_debate_state: dict | None = Field(default=None, sa_column=Column(JSON), description="Risk Management Team 토론 과정")
     
     # 최종 결과물
-    final_trade_decision: str | None = Field(default=None, description="최종 거래 결정")
+    final_trade_decision: str | None = Field(default=None, sa_column=Column(Text), description="최종 거래 결정")
-    final_report: str | None = Field(default=None, description="전체 통합 리포트")
+    final_report: str | None = Field(default=None, sa_column=Column(Text), description="전체 통합 리포트")
     
     # 실행 결과 정보
-    error_message: str | None = None
+    error_message: str | None = Field(default=None, sa_column=Column(Text))
     completed_at: datetime | None = None
     created_at : datetime = Field(nullable=False)
     updated_at : datetime = Field(nullable=False)

backend/analysis/infra/repository/analysis_repo.py

@@ -28,30 +28,7 @@ class AnalysisRepository(IAnalysisRepository):
 
     def save(self, analysis: AnalysisVO) -> AnalysisVO:
         new_analysis = Analysis(
-            id=analysis.id,
+            **analysis.model_dump()
-            member_id=analysis.member_id,
-            ticker=analysis.ticker,
-            analysis_date=date.fromisoformat(analysis.analysis_date),
-            analysts_selected=analysis.analysts_selected,
-            research_depth=analysis.research_depth,
-            llm_provider=analysis.llm_provider,
-            backend_url=analysis.backend_url,
-            shallow_thinker=analysis.shallow_thinker,
-            deep_thinker=analysis.deep_thinker,
-            status=analysis.status,
-            market_report=analysis.market_report,
-            sentiment_report=analysis.sentiment_report,
-            news_report=analysis.news_report,
-            fundamentals_report=analysis.fundamentals_report,
-            investment_debate_state=analysis.investment_debate_state,
-            trader_investment_plan=analysis.trader_investment_plan,
-            risk_debate_state=analysis.risk_debate_state,
-            final_trade_decision=analysis.final_trade_decision,
-            final_report=analysis.final_report,
-            error_message=analysis.error_message,
-            completed_at=analysis.completed_at,
-            created_at=analysis.created_at,
-            updated_at=analysis.updated_at
         )
         
         self.session.add(new_analysis)
@@ -67,14 +44,12 @@ class AnalysisRepository(IAnalysisRepository):
             return None
 
         # AnalysisVO의 데이터를 SQLModel 객체에 업데이트
-        vo_data = analysis_vo.sqlmodel_dump(exclude_unset=True)
+        analysis_data = analysis_vo.model_dump(exclude_unset=True)
-        for key, value in vo_data.items():
-            if hasattr(analysis, key) and key != 'id':  # id는 변경하지 않음
-                setattr(analysis, key, value)
         
         analysis.updated_at = datetime.now()
-        self.session.add(analysis)
+        analysis.sqlmodel_update(analysis_data)
+        
         self.session.flush()
-        self.session.refresh(analysis)
+        
 
         return AnalysisVO(**row_to_dict(analysis))

backend/analysis/interface/controller/analysis_controller.py

@@ -1,5 +1,5 @@
 from typing import Annotated
-from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException, status
+from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException, status, WebSocket, WebSocketDisconnect
 from analysis.interface.dto import (
     AnalysisSessionResponse,
     TradingAnalysisRequest,
@@ -9,6 +9,7 @@ from utils.auth import get_current_member, CurrentMember
 from dependency_injector.wiring import inject, Provide
 from analysis.application.analysis_service import AnalysisService
 from utils.containers import Container
+from analysis.application.websocket_manager import WebSocketManager
 
 router = APIRouter(prefix="/analysis", tags=["analysis"])
 
@@ -40,6 +41,7 @@ def start_analysis_session(
 ):
     """
     새로운 분석 세션을 시작합니다.
+    
     """
     try:
         new_analysis = analysis_service.create_analysis(current_member.id, request, background_tasks)
@@ -69,7 +71,7 @@ def get_analysis_result(
     return AnalysisResultResponse(
         id=analysis.id,
         ticker=analysis.ticker,
-        analysis_date=analysis.analysis_date,
+        analysis_date=analysis.analysis_date.isoformat() if hasattr(analysis.analysis_date, 'isoformat') else str(analysis.analysis_date),
         status=analysis.status,
         market_report=analysis.market_report,
         sentiment_report=analysis.sentiment_report,
@@ -106,3 +108,30 @@ def get_analysis_status(
         "updated_at": analysis.updated_at.isoformat(),
         "error_message": analysis.error_message
     }
+
+@router.websocket("/ws")
+@inject
+async def websocket_endpoint(
+    websocket: WebSocket,
+    current_member: Annotated[CurrentMember, Depends(get_current_member)],
+    websocket_manager: Annotated[WebSocketManager, Depends(Provide[Container.websocket_manager])]
+):
+    """
+    WebSocket endpoint for real-time analysis updates
+    """
+    try:
+        # Connect the websocket
+        await websocket_manager.connect(websocket, current_member.id)
+        
+        try:
+            # Keep connection alive
+            while True:
+                # Wait for messages from client (like ping/pong)
+                data = await websocket.receive_text()
+                # Echo back for heartbeat
+                if data == "ping":
+                    await websocket.send_text("pong")
+        except WebSocketDisconnect:
+            websocket_manager.disconnect(websocket, current_member.id)
+    except Exception as e:
+        await websocket.close(code=1011, reason=str(e))

backend/analysis/interface/dto.py

@@ -11,14 +11,14 @@ class AnalystType(str, Enum):
     FUNDAMENTALS = "fundamentals"
 
 class TradingAnalysisRequest(BaseModel):
-    ticker: str
+    ticker: str = "NVDA"
-    analysis_date: str
+    analysis_date: str = "2025-07-07"
-    analysts: List[AnalystType]
+    analysts: List[AnalystType] = [AnalystType.MARKET, AnalystType.SOCIAL, AnalystType.NEWS, AnalystType.FUNDAMENTALS]
     research_depth: int = 3
     llm_provider: str = "openai"
     backend_url: str = "https://api.openai.com/v1"
     shallow_thinker: str = "gpt-4o-mini"
-    deep_thinker: str = "gpt-4o"
+    deep_thinker: str = "gpt-4o-mini"
 
 class AnalysisSessionResponse(BaseModel):
     id : str

backend/main.py

@@ -5,6 +5,16 @@ from utils.containers import Container
 
 from analysis.interface.controller.analysis_controller import router as analysis_router
 from member.interface.controller.member_controller import router as member_router
+import logging
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),  # 콘솔 출력
+    ]
+)
 
 
 

backend/member/application/member_service.py

@@ -14,12 +14,12 @@ class MemberService:
         self,
         member_repo: IMemberRepository,
         crypto: Crypto,
-        db_session: Session,
+        session: Session,
         ulid: ULID
     ):
         self.member_repo = member_repo
         self.crypto = crypto
-        self.db_session = db_session
+        self.db_session = session
         self.ulid = ulid
 
     def create_member(

backend/member/interface/controller/member_controller.py

@@ -6,6 +6,8 @@ from utils.containers import Container
 from dependency_injector.wiring import inject, Provide
 from fastapi.security import OAuth2PasswordRequestForm
 from utils.auth import get_current_member, CurrentMember, get_admin_member
+from analysis.interface.dto import AnalysisSessionResponse
+from analysis.application.analysis_service import AnalysisService
 
 router = APIRouter(prefix="/members", tags=["members"])
 
@@ -67,12 +69,3 @@ def get_member(
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Member not found")
     return member
 
-# @router.get("/analysis-sessions", response_model=list[AnalysisSessionResponse])
-# @inject
-# def get_member_analysis_sessions(
-#     current_member: Annotated[CurrentMember | None, Depends(get_current_member)] = None,
-#     member_service: Annotated[MemberService | None, Depends(Provide[Container.member_service])] = None
-# ):
-    
-#     result = member_service.get_analysis_sessions_by_member(current_member.id)
-#     return result

backend/utils/containers.py

@@ -5,6 +5,7 @@ from member.infra.repository.member_repo import MemberRepository
 from member.application.member_service import MemberService
 from analysis.application.analysis_service import AnalysisService
 from analysis.infra.repository.analysis_repo import AnalysisRepository
+from analysis.application.websocket_manager import WebSocketManager
 from ulid import ULID
 
 class Container(containers.DeclarativeContainer):
@@ -12,32 +13,37 @@ class Container(containers.DeclarativeContainer):
         packages=["member", "analysis"]
     )
 
-    db_session = providers.Resource(get_session)
+    session = providers.Resource(get_session)
     crypto = providers.Factory(Crypto)
     ulid = providers.Factory(ULID)
 
     member_repo = providers.Factory(
         MemberRepository,
-        session=db_session
+        session=session
     )
 
     member_service = providers.Factory(
         MemberService,
         member_repo=member_repo,
         crypto=crypto,
-        db_session=db_session,
+        session=session,
         ulid=ulid
     )
 
     analysis_repo = providers.Factory(
         AnalysisRepository,
-        session=db_session
+        session=session
+    )
+
+    websocket_manager = providers.Singleton(
+        WebSocketManager
     )
 
     analysis_service = providers.Factory(
         AnalysisService,
         analysis_repo=analysis_repo,
-        db_session=db_session,
+        session=session,
-        ulid=ulid
+        ulid=ulid,
+        websocket_manager=websocket_manager
     )