feat: add ReAct agent for Build Portfolio workflow

- Add PortfolioBuilderAgent with LangGraph and 7 financial tools
- Add goal wizard UI with investment goals, risk tolerance, constraints
- Enable Build Portfolio task in workflow router
- Add langchain-anthropic and langchain-core dependencies
- Optimise historical price data to return summaries

.gitignore

@@ -198,4 +198,6 @@ cython_debug/
 *.claude/
 
 # Research Documents
-*finance-agentic-ai/.playwright-mcp/
+*finance-agentic-ai/
+*.playwright-mcp/
+*thoughts/

app.py

@@ -1909,13 +1909,13 @@ def create_interface() -> gr.Blocks:
                         size="lg"
                     )
 
-                # Build Portfolio - coming soon
+                # Build Portfolio - enabled
                 with gr.Column(scale=1, min_width=200):
                     task_build_btn = gr.Button(
-                        value="🏗️\n\nBuild Portfolio\n\nAI helps construct a portfolio based on your goals\n\n🔒 Coming Soon",
+                        value="🏗️\n\nBuild Portfolio\n\nAI helps construct a portfolio based on your goals",
                         elem_classes=["task-card"],
-                        variant="secondary",
-                        interactive=False,
+                        variant="primary",
+                        interactive=True,
                         size="lg"
                     )
 
@@ -1939,6 +1939,76 @@ def create_interface() -> gr.Blocks:
                         size="lg"
                     )
 
+        # Build Portfolio Page (shown when Build Portfolio task selected)
+        with gr.Group(visible=False, elem_classes="build-portfolio-container") as build_page:
+            gr.Markdown("## Build Your Portfolio", elem_classes="section-title")
+            gr.Markdown("Tell us about your investment goals and we'll build a portfolio for you.")
+
+            with gr.Row(equal_height=True):
+                # Left column: Goal settings
+                with gr.Column(scale=2):
+                    with gr.Group(elem_classes="input-card"):
+                        build_goals = gr.CheckboxGroup(
+                            choices=["Growth", "Income", "Capital Preservation", "Speculation"],
+                            label="Investment Goals",
+                            info="Select one or more investment objectives"
+                        )
+
+                        build_risk_tolerance = gr.Slider(
+                            minimum=1,
+                            maximum=10,
+                            value=5,
+                            step=1,
+                            label="Risk Tolerance",
+                            info="1 = Very Conservative, 10 = Very Aggressive"
+                        )
+
+                        build_constraints = gr.Textbox(
+                            label="Constraints (Optional)",
+                            placeholder="e.g., 'No crypto, ESG focused, minimum 10 stocks, max 5% per position'",
+                            lines=3,
+                            info="Any specific requirements or restrictions"
+                        )
+
+                        build_show_reasoning = gr.Checkbox(
+                            label="Show AI Reasoning",
+                            value=False,
+                            info="Display the AI's thought process and tool usage"
+                        )
+
+                        with gr.Row():
+                            build_submit_btn = gr.Button(
+                                "Build My Portfolio",
+                                variant="primary",
+                                size="lg"
+                            )
+                            build_back_btn = gr.Button(
+                                "Back",
+                                variant="secondary",
+                                size="lg"
+                            )
+
+                # Right column: Results
+                with gr.Column(scale=3):
+                    with gr.Group(elem_classes="preview-card", visible=False) as build_results_container:
+                        build_status = gr.Markdown("", elem_classes="build-status")
+
+                        with gr.Group(visible=False) as build_reasoning_container:
+                            gr.Markdown("### AI Reasoning")
+                            build_reasoning_trace = gr.JSON(label="Reasoning Trace")
+
+                        build_portfolio_table = gr.Dataframe(
+                            headers=["Ticker", "Allocation %", "Reasoning"],
+                            label="Suggested Portfolio",
+                            interactive=False
+                        )
+
+                        build_final_response = gr.Markdown("", label="Summary")
+
+                        with gr.Row():
+                            build_accept_btn = gr.Button("Accept & Analyse", variant="primary", size="sm")
+                            build_regenerate_btn = gr.Button("Regenerate", variant="secondary", size="sm")
+
         # Input Page with side-by-side layout (hidden until authenticated)
         with gr.Group(visible=False) as input_page:
             # Side-by-side input and preview (2:3 ratio for wider preview)
@@ -2375,7 +2445,8 @@ def create_interface() -> gr.Blocks:
                 task_page: gr.update(visible=False),
                 input_page: gr.update(visible=True),
                 results_page: gr.update(visible=False),
-                history_page: gr.update(visible=False)
+                history_page: gr.update(visible=False),
+                build_page: gr.update(visible=False)
             }
 
         def show_task_page():
@@ -2383,9 +2454,139 @@ def create_interface() -> gr.Blocks:
                 task_page: gr.update(visible=True),
                 input_page: gr.update(visible=False),
                 results_page: gr.update(visible=False),
-                history_page: gr.update(visible=False)
+                history_page: gr.update(visible=False),
+                build_page: gr.update(visible=False)
             }
 
+        def show_build_page():
+            return {
+                task_page: gr.update(visible=False),
+                input_page: gr.update(visible=False),
+                results_page: gr.update(visible=False),
+                history_page: gr.update(visible=False),
+                build_page: gr.update(visible=True)
+            }
+
+        async def handle_build_portfolio(goals, risk_tolerance, constraints, show_reasoning, session_state):
+            """Handle the Build Portfolio workflow.
+
+            Args:
+                goals: List of selected investment goals
+                risk_tolerance: Risk tolerance score 1-10
+                constraints: User constraints text
+                show_reasoning: Whether to show reasoning trace
+                session_state: User session
+
+            Returns:
+                Tuple of UI updates for build results
+            """
+            try:
+                if not goals:
+                    return (
+                        gr.update(visible=True),  # build_results_container
+                        "Please select at least one investment goal.",  # build_status
+                        gr.update(visible=False),  # build_reasoning_container
+                        [],  # build_reasoning_trace
+                        [],  # build_portfolio_table
+                        ""  # build_final_response
+                    )
+
+                # Initialise MCP router and workflow router
+                from backend.mcp_router import MCPRouter
+                from backend.agents.workflow_router import WorkflowRouter
+
+                mcp_router = MCPRouter()
+                workflow_router = WorkflowRouter(mcp_router)
+
+                # Run the build workflow
+                result = await workflow_router.route_build(
+                    goals=goals,
+                    risk_tolerance=int(risk_tolerance),
+                    constraints=constraints or ""
+                )
+
+                # Extract portfolio data for table
+                portfolio_data = []
+                for item in result.get("portfolio", []):
+                    portfolio_data.append([
+                        item.get("ticker", ""),
+                        item.get("allocation", 0),
+                        item.get("reasoning", "")
+                    ])
+
+                # If no portfolio extracted, show the final response
+                if not portfolio_data and result.get("final_response"):
+                    return (
+                        gr.update(visible=True),
+                        "Portfolio built successfully!",
+                        gr.update(visible=show_reasoning),
+                        result.get("reasoning_trace", []),
+                        [],
+                        result.get("final_response", "")
+                    )
+
+                return (
+                    gr.update(visible=True),
+                    "Portfolio built successfully!",
+                    gr.update(visible=show_reasoning),
+                    result.get("reasoning_trace", []),
+                    portfolio_data,
+                    result.get("final_response", "")
+                )
+
+            except Exception as e:
+                logger.error(f"Build portfolio error: {e}")
+                return (
+                    gr.update(visible=True),
+                    f"Error building portfolio: {str(e)}",
+                    gr.update(visible=False),
+                    [],
+                    [],
+                    ""
+                )
+
+        def sync_handle_build_portfolio(goals, risk_tolerance, constraints, show_reasoning, session_state):
+            """Synchronous wrapper for handle_build_portfolio."""
+            return asyncio.run(handle_build_portfolio(goals, risk_tolerance, constraints, show_reasoning, session_state))
+
+        def handle_build_accept(portfolio_table):
+            """Accept built portfolio and populate input for analysis.
+
+            Args:
+                portfolio_table: DataFrame with ticker and allocation data
+
+            Returns:
+                Tuple of values for each output component
+            """
+            if portfolio_table is None or len(portfolio_table) == 0:
+                return (
+                    "",  # portfolio_input
+                    gr.update(visible=False),  # task_page
+                    gr.update(visible=True),  # input_page
+                    gr.update(visible=False),  # results_page
+                    gr.update(visible=False),  # history_page
+                    gr.update(visible=False)  # build_page
+                )
+
+            # Convert portfolio table to input format
+            lines = []
+            for row in portfolio_table:
+                ticker = row[0] if len(row) > 0 else ""
+                allocation = row[1] if len(row) > 1 else 0
+                if ticker:
+                    lines.append(f"{ticker} {allocation}%")
+
+            portfolio_text = "\n".join(lines)
+
+            return (
+                portfolio_text,  # portfolio_input
+                gr.update(visible=False),  # task_page
+                gr.update(visible=True),  # input_page
+                gr.update(visible=False),  # results_page
+                gr.update(visible=False),  # history_page
+                gr.update(visible=False)  # build_page
+            )
+
         async def load_history(session_state):
             """Load analysis history from database.
 
@@ -3456,13 +3657,62 @@ Please try again with different parameters.
         # Navigation event handlers
         nav_new_analysis.click(
             show_task_page,
-            outputs=[task_page, input_page, results_page, history_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page]
         )
 
         # Task card event handlers
         task_analyse_btn.click(
             show_input_page,
-            outputs=[task_page, input_page, results_page, history_page]
+            outputs=[task_page, input_page, results_page, history_page, build_page]
+        )
+
+        task_build_btn.click(
+            show_build_page,
+            outputs=[task_page, input_page, results_page, history_page, build_page]
+        )
+
+        # Build page event handlers
+        build_back_btn.click(
+            show_task_page,
+            outputs=[task_page, input_page, results_page, history_page, build_page]
+        )
+
+        build_submit_btn.click(
+            sync_handle_build_portfolio,
+            inputs=[build_goals, build_risk_tolerance, build_constraints, build_show_reasoning, session_state],
+            outputs=[
+                build_results_container,
+                build_status,
+                build_reasoning_container,
+                build_reasoning_trace,
+                build_portfolio_table,
+                build_final_response
+            ]
+        )
+
+        build_show_reasoning.change(
+            lambda x: gr.update(visible=x),
+            inputs=[build_show_reasoning],
+            outputs=[build_reasoning_container]
+        )
+
+        build_accept_btn.click(
+            handle_build_accept,
+            inputs=[build_portfolio_table],
+            outputs=[portfolio_input, task_page, input_page, results_page, history_page, build_page]
+        )
+
+        build_regenerate_btn.click(
+            sync_handle_build_portfolio,
+            inputs=[build_goals, build_risk_tolerance, build_constraints, build_show_reasoning, session_state],
+            outputs=[
+                build_results_container,
+                build_status,
+                build_reasoning_container,
+                build_reasoning_trace,
+                build_portfolio_table,
+                build_final_response
+            ]
         )
 
         nav_view_history.click(

backend/agents/react_agent.py

@@ -0,0 +1,411 @@
+"""ReAct agent for dynamic portfolio building.
+
+Uses LangGraph for tool calling and dynamic routing based on user goals.
+"""
+
+from typing import Annotated, Literal, Any
+from typing_extensions import TypedDict
+import logging
+import re
+
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode
+from langchain_core.messages import ToolMessage, HumanMessage
+from langchain_core.tools import tool
+from langchain_anthropic import ChatAnthropic
+
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class ReactAgentState(TypedDict):
+    """State for ReAct agent."""
+    messages: Annotated[list, add_messages]
+    user_goals: list[str]
+    risk_tolerance: int
+    constraints: str
+    selected_tools: list[str]
+    portfolio_result: dict
+
+
+class PortfolioBuilderAgent:
+    """ReAct agent for building portfolios based on user goals.
+
+    Uses LangGraph with tool calling for dynamic tool selection based on
+    user-specified investment goals, risk tolerance, and constraints.
+    """
+
+    def __init__(self, mcp_router):
+        """Initialise the portfolio builder agent.
+
+        Args:
+            mcp_router: MCP router instance for calling MCP servers
+        """
+        self.mcp_router = mcp_router
+        self.model = ChatAnthropic(
+            model=settings.anthropic_model,
+            api_key=settings.anthropic_api_key,
+            max_tokens=4096,
+        )
+        self.tools = self._register_tools()
+        self.tools_by_name = {t.name: t for t in self.tools}
+        self.workflow = self._build_workflow()
+
+    def _register_tools(self) -> list:
+        """Register available tools for portfolio building."""
+
+        mcp_router = self.mcp_router
+
+        @tool
+        async def fetch_market_data(tickers: list[str]) -> dict:
+            """Fetch current market data for given tickers.
+
+            Args:
+                tickers: List of stock ticker symbols to fetch data for
+
+            Returns:
+                Dictionary mapping tickers to their market data
+            """
+            results = {}
+            for ticker in tickers:
+                try:
+                    data = await mcp_router.call_yahoo_finance_mcp(
+                        "get_quote", {"tickers": [ticker]}
+                    )
+                    results[ticker] = data
+                except Exception as e:
+                    logger.error(f"Error fetching market data for {ticker}: {e}")
+                    results[ticker] = {"error": str(e)}
+            return results
+
+        @tool
+        async def get_fundamentals(ticker: str) -> dict:
+            """Get fundamental analysis for a ticker.
+
+            Args:
+                ticker: Stock ticker symbol
+
+            Returns:
+                Fundamental data including financials, ratios, and metrics
+            """
+            try:
+                return await mcp_router.call_fmp_mcp(
+                    "get_company_profile", {"ticker": ticker}
+                )
+            except Exception as e:
+                logger.error(f"Error getting fundamentals for {ticker}: {e}")
+                return {"error": str(e)}
+
+        @tool
+        async def get_historical_prices(ticker: str, period: str = "3mo") -> dict:
+            """Get historical price data summary for a ticker.
+
+            Args:
+                ticker: Stock ticker symbol
+                period: Time period (e.g., '1mo', '3mo', '6mo')
+
+            Returns:
+                Summary of historical price data with key statistics
+            """
+            try:
+                data = await mcp_router.call_yahoo_finance_mcp(
+                    "get_historical_data", {"ticker": ticker, "period": period}
+                )
+                if not data or "error" in data:
+                    return data
+
+                prices = data.get("close_prices", [])
+                if not prices:
+                    return {"error": "No price data available"}
+
+                return {
+                    "ticker": ticker,
+                    "period": period,
+                    "data_points": len(prices),
+                    "latest_price": prices[-1] if prices else None,
+                    "first_price": prices[0] if prices else None,
+                    "price_change_pct": round(((prices[-1] - prices[0]) / prices[0]) * 100, 2) if prices else None,
+                    "high": max(prices) if prices else None,
+                    "low": min(prices) if prices else None,
+                    "avg": round(sum(prices) / len(prices), 2) if prices else None,
+                }
+            except Exception as e:
+                logger.error(f"Error getting historical prices for {ticker}: {e}")
+                return {"error": str(e)}
+
+        @tool
+        async def calculate_technicals(ticker: str, prices: list[float]) -> dict:
+            """Calculate technical indicators for a ticker.
+
+            Args:
+                ticker: Stock ticker symbol
+                prices: List of historical closing prices
+
+            Returns:
+                Technical indicators including RSI, MACD, Bollinger Bands, etc.
+            """
+            try:
+                return await mcp_router.call_feature_extraction_mcp(
+                    "extract_technical_features",
+                    {
+                        "ticker": ticker,
+                        "prices": prices,
+                        "include_momentum": True,
+                        "include_volatility": True,
+                        "include_trend": True,
+                    }
+                )
+            except Exception as e:
+                logger.error(f"Error calculating technicals for {ticker}: {e}")
+                return {"error": str(e)}
+
+        @tool
+        async def optimise_allocation(
+            tickers: list[str],
+            returns_data: dict[str, list[float]]
+        ) -> dict:
+            """Optimise portfolio allocation using Hierarchical Risk Parity.
+
+            Args:
+                tickers: List of ticker symbols
+                returns_data: Dictionary mapping tickers to their return series
+
+            Returns:
+                Optimised weights for each ticker
+            """
+            try:
+                return await mcp_router.call_portfolio_optimizer_mcp(
+                    "optimize_hrp", {"tickers": tickers, "returns": returns_data}
+                )
+            except Exception as e:
+                logger.error(f"Error optimising allocation: {e}")
+                return {"error": str(e)}
+
+        @tool
+        async def assess_risk(
+            weights: dict[str, float],
+            returns_data: dict[str, list[float]]
+        ) -> dict:
+            """Assess portfolio risk metrics.
+
+            Args:
+                weights: Dictionary mapping tickers to allocation weights
+                returns_data: Dictionary mapping tickers to their return series
+
+            Returns:
+                Risk metrics including VaR, CVaR, volatility, etc.
+            """
+            try:
+                return await mcp_router.call_risk_analyzer_mcp(
+                    "analyze_risk", {"weights": weights, "returns": returns_data}
+                )
+            except Exception as e:
+                logger.error(f"Error assessing risk: {e}")
+                return {"error": str(e)}
+
+        @tool
+        async def get_news_sentiment(ticker: str) -> dict:
+            """Get news sentiment analysis for a ticker.
+
+            Args:
+                ticker: Stock ticker symbol
+
+            Returns:
+                Sentiment scores and recent news analysis
+            """
+            try:
+                return await mcp_router.call_news_sentiment_mcp(
+                    "analyze_sentiment", {"ticker": ticker}
+                )
+            except Exception as e:
+                logger.error(f"Error getting news sentiment for {ticker}: {e}")
+                return {"error": str(e)}
+
+        return [
+            fetch_market_data,
+            get_fundamentals,
+            get_historical_prices,
+            calculate_technicals,
+            optimise_allocation,
+            assess_risk,
+            get_news_sentiment,
+        ]
+
+    def _build_workflow(self):
+        """Build ReAct workflow with tool calling."""
+
+        builder = StateGraph(ReactAgentState)
+
+        async def agent_node(state: ReactAgentState) -> dict:
+            """Call model with available tools."""
+            system_prompt = self._build_system_prompt(state)
+            model_with_tools = self.model.bind_tools(self.tools)
+
+            messages = [
+                {"role": "system", "content": system_prompt}
+            ] + state["messages"]
+
+            response = await model_with_tools.ainvoke(messages)
+            return {"messages": [response]}
+
+        tool_node = ToolNode(tools=self.tools)
+
+        def should_continue(state: ReactAgentState) -> Literal["tools", "end"]:
+            """Determine if agent should continue or finish."""
+            last_message = state["messages"][-1]
+
+            if not hasattr(last_message, 'tool_calls') or not last_message.tool_calls:
+                return "end"
+
+            return "tools"
+
+        builder.add_node("agent", agent_node)
+        builder.add_node("tools", tool_node)
+
+        builder.add_edge(START, "agent")
+        builder.add_conditional_edges(
+            "agent",
+            should_continue,
+            {"tools": "tools", "end": END}
+        )
+        builder.add_edge("tools", "agent")
+
+        return builder.compile()
+
+    def _build_system_prompt(self, state: ReactAgentState) -> str:
+        """Build system prompt based on user goals.
+
+        Args:
+            state: Current agent state with user preferences
+
+        Returns:
+            Formatted system prompt
+        """
+        goals = ", ".join(state["user_goals"]) if state["user_goals"] else "General investing"
+        risk = state["risk_tolerance"]
+        constraints = state["constraints"] or "None specified"
+
+        return f"""You are an expert portfolio builder. Build a portfolio based on:
+
+Goals: {goals}
+Risk Tolerance: {risk}/10
+Constraints: {constraints}
+
+Use the available tools to:
+1. Research suitable stocks/ETFs based on the goals
+2. Fetch market data and fundamentals
+3. Calculate technical indicators
+4. Optimise allocation using HRP
+5. Assess overall risk
+
+Think step-by-step and explain your reasoning. When you have a final portfolio
+recommendation, provide it in this format:
+
+PORTFOLIO RECOMMENDATION:
+- [TICKER]: [ALLOCATION]% - [REASONING]
+- [TICKER]: [ALLOCATION]% - [REASONING]
+...
+
+TOTAL EXPECTED RETURN: [X]%
+ESTIMATED RISK (VOLATILITY): [Y]%
+KEY CONSIDERATIONS: [Summary]"""
+
+    async def run(
+        self,
+        goals: list[str],
+        risk_tolerance: int,
+        constraints: str
+    ) -> dict:
+        """Run the ReAct agent to build a portfolio.
+
+        Args:
+            goals: List of investment goals (e.g., ['Growth', 'Income'])
+            risk_tolerance: Risk tolerance score from 1-10
+            constraints: User-specified constraints as text
+
+        Returns:
+            Dictionary containing portfolio, reasoning trace, and messages
+        """
+        logger.info(f"Building portfolio with goals={goals}, risk={risk_tolerance}")
+
+        initial_state: ReactAgentState = {
+            "messages": [
+                HumanMessage(content="Build me a portfolio based on my goals and constraints.")
+            ],
+            "user_goals": goals,
+            "risk_tolerance": risk_tolerance,
+            "constraints": constraints,
+            "selected_tools": [],
+            "portfolio_result": {}
+        }
+
+        result = await self.workflow.ainvoke(initial_state)
+
+        reasoning_trace = self._extract_reasoning_trace(result["messages"])
+        portfolio = self._extract_portfolio(result["messages"])
+
+        return {
+            "portfolio": portfolio,
+            "reasoning_trace": reasoning_trace,
+            "final_response": result["messages"][-1].content if result["messages"] else ""
+        }
+
+    def _extract_reasoning_trace(self, messages: list) -> list[dict]:
+        """Extract reasoning trace from message history.
+
+        Args:
+            messages: List of messages from the workflow
+
+        Returns:
+            List of reasoning steps with thoughts, actions, and observations
+        """
+        reasoning_trace = []
+
+        for msg in messages:
+            if hasattr(msg, 'tool_calls') and msg.tool_calls:
+                for tc in msg.tool_calls:
+                    reasoning_trace.append({
+                        "thought": msg.content if msg.content else "Executing tool",
+                        "action": tc["name"],
+                        "args": tc["args"]
+                    })
+            elif isinstance(msg, ToolMessage):
+                content = msg.content
+                if isinstance(content, str) and len(content) > 500:
+                    content = content[:500] + "..."
+                reasoning_trace.append({
+                    "observation": content
+                })
+
+        return reasoning_trace
+
+    def _extract_portfolio(self, messages: list) -> list[dict]:
+        """Extract portfolio recommendations from final message.
+
+        Args:
+            messages: List of messages from the workflow
+
+        Returns:
+            List of portfolio holdings with ticker, allocation, and reasoning
+        """
+        if not messages:
+            return []
+
+        final_message = messages[-1]
+        content = final_message.content if hasattr(final_message, 'content') else ""
+
+        portfolio = []
+        lines = content.split('\n')
+
+        for line in lines:
+            match = re.match(r'[-•]\s*([A-Z]{1,5}):\s*(\d+(?:\.\d+)?)\s*%\s*[-–]\s*(.+)', line)
+            if match:
+                portfolio.append({
+                    "ticker": match.group(1),
+                    "allocation": float(match.group(2)),
+                    "reasoning": match.group(3).strip()
+                })
+
+        return portfolio

backend/agents/workflow_router.py

@@ -8,6 +8,7 @@ from enum import Enum
 from typing import Optional, Dict, Any, List
 
 from backend.agents.workflow import PortfolioAnalysisWorkflow
+from backend.agents.react_agent import PortfolioBuilderAgent
 from backend.agents.personas import PersonaType
 from backend.models.agent_state import AgentState
 
@@ -98,7 +99,10 @@ class WorkflowRouter:
             return await workflow.run(initial_state)
 
         elif task == TaskType.BUILD:
-            raise ValueError("Build Portfolio workflow not yet implemented")
+            raise ValueError(
+                "Build Portfolio requires different parameters. "
+                "Use route_build() method instead."
+            )
 
         elif task == TaskType.COMPARE:
             raise ValueError("Compare Strategies workflow not yet implemented")
@@ -109,6 +113,25 @@ class WorkflowRouter:
         else:
             raise ValueError(f"Unknown task type: {task}")
 
+    async def route_build(
+        self,
+        goals: List[str],
+        risk_tolerance: int,
+        constraints: str
+    ) -> Dict[str, Any]:
+        """Route to the Build Portfolio workflow.
+
+        Args:
+            goals: List of investment goals (e.g., ['Growth', 'Income'])
+            risk_tolerance: Risk tolerance score from 1-10
+            constraints: User-specified constraints as text
+
+        Returns:
+            Build result with portfolio, reasoning trace, and final response
+        """
+        agent = PortfolioBuilderAgent(self.mcp_router)
+        return await agent.run(goals, risk_tolerance, constraints)
+
     def get_available_tasks(self) -> list[Dict[str, Any]]:
         """Get list of available tasks with their status.
 
@@ -129,7 +152,7 @@ class WorkflowRouter:
                 "title": "Build Portfolio",
                 "description": "AI helps construct a portfolio based on your goals",
                 "icon": "hammer",
-                "enabled": False,
+                "enabled": True,
                 "task_type": TaskType.BUILD,
             },
             {

pyproject.toml

@@ -11,6 +11,8 @@ dependencies = [
     "instructor>=1.6.4",
     # Agent Orchestration
     "langgraph>=0.1.0",
+    "langchain-anthropic>=0.1.0",
+    "langchain-core>=0.2.0",
     # MCP Framework
     "fastmcp>=2.12.5",
     "mcp>=1.15.0",

uv.lock

@@ -2064,6 +2064,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260, upload-time = "2025-08-10T21:27:36.606Z" },
 ]
 
+[[package]]
+name = "langchain-anthropic"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anthropic" },
+    { name = "langchain-core" },
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d2/d3/8ac7d664e87aa9bdf5f6a4d55324316933aec8beb1690932dbe7b63416e2/langchain_anthropic-1.1.0.tar.gz", hash = "sha256:427e102b76a417fb5713e81e853225e7459d71fc7abdf4d86722f0e01ad43845", size = 684087, upload-time = "2025-11-17T21:31:31.146Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/95/f340acdd8d9f392606f026a1326a33cfb1f9b172c7607c70ab0c2b43d74d/langchain_anthropic-1.1.0-py3-none-any.whl", hash = "sha256:2593f10b984448e31a9fd486ab2f7ebc8a0f7f82ba1ca477339e4f5ddd7f0e8d", size = 47793, upload-time = "2025-11-17T21:31:29.979Z" },
+]
+
 [[package]]
 name = "langchain-core"
 version = "1.0.5"
@@ -3476,6 +3490,8 @@ dependencies = [
     { name = "granite-tsfm" },
     { name = "httpx" },
     { name = "instructor" },
+    { name = "langchain-anthropic" },
+    { name = "langchain-core" },
     { name = "langgraph" },
     { name = "matplotlib" },
     { name = "mcp" },
@@ -3531,6 +3547,8 @@ requires-dist = [
     { name = "granite-tsfm", specifier = ">=0.2.22" },
     { name = "httpx", specifier = ">=0.25.0" },
     { name = "instructor", specifier = ">=1.6.4" },
+    { name = "langchain-anthropic", specifier = ">=0.1.0" },
+    { name = "langchain-core", specifier = ">=0.2.0" },
     { name = "langgraph", specifier = ">=0.1.0" },
     { name = "matplotlib", specifier = ">=3.8.0" },
     { name = "mcp", specifier = ">=1.15.0" },