DEV Community: grahammccain

Multi-Agent Stock Research with CrewAI + Chart Library

grahammccain — Mon, 06 Apr 2026 17:23:46 +0000

When you ask a single AI agent to research a stock, it tries to do everything at once: check the chart pattern, assess the market, evaluate sectors, and synthesize a view. The result is usually shallow.

Multi-agent systems fix this by splitting work across specialists -- exactly how institutional research desks operate. CrewAI lets you build that structure with AI agents and Chart Library's pattern intelligence API.

The Crew Design: Two Specialist Agents

Pattern Analyst -- specializes in individual stock chart analysis. Uses Chart Library's intelligence endpoint to find historically similar charts, reads forward return statistics, and runs scenario stress tests. Always cites specific numbers: "7 of 10 similar patterns went up over 5 days, averaging +2.3%."

Regime Analyst -- specializes in the market-wide environment. Checks SPY/QQQ regime status, sector rotation, and crowding risk. Frames everything as historical analogy: "similar conditions historically led to..." rather than predictions.

Agent backstories matter more than you'd expect. A backstory that says "you never make predictions, you present historical context" produces very different output than "you are a bold market forecaster."

Defining the Tools

Each agent gets curated tools from Chart Library's Python SDK:

pip install crewai crewai-tools chartlibrary

Pattern Analyst tools:

chart_intelligence -- calls cl.intelligence(symbol, date) for 10 most similar historical patterns + forward returns
scenario_stress_test -- calls cl.scenario(symbol, market_move_pct) for "what if SPY drops 5%?"
daily_top_picks -- calls cl.discover(limit=10) for today's top patterns

Regime Analyst tools:

market_regime -- calls cl.regime(compact=True) for SPY, QQQ, and 11 sector ETFs
crowding_detector -- calls cl.crowding() for systematic risk signals
sector_rotation -- calls cl.sector_rotation(lookback) for momentum rankings

Building the Tasks

The order matters: regime assessment first (establishes context), then stock analysis (uses that context), then synthesis (combines both).

Task 1 - Regime Assessment: Check SPY/QQQ, identify leading/lagging sectors, evaluate crowding risk.

Task 2 - Stock Analysis: For each symbol in your watchlist, report match count, quality, forward returns. Receives Task 1's output as context -- so findings can be framed like "NVDA's bullish pattern aligns with the current risk-on regime."

Task 3 - Synthesis: Produces a structured briefing: Market Environment, Stock Highlights, Risk Factors, Bottom Line.

Running the Crew

crew = Crew(
    agents=[pattern_analyst, regime_analyst],
    tasks=[regime_task, analysis_task, synthesis_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff()

Example Output

The Regime Analyst checks SPY: 7 of 10 historically similar regimes gained over 10 days. Tech (XLK) and Industrials (XLI) leading. Moderate crowding in large-cap tech.

The Pattern Analyst analyzes each symbol:

NVDA: 10 matches, top match 94% similarity, 8/10 positive over 5 days (+3.1% avg)
AAPL: More mixed -- 6/10 positive, +0.8% average
TSLA: Historically volatile, wide outcome range

The synthesis combines both: bullish regime supports NVDA, AAPL is neutral, TSLA's wide range means sizing matters more than direction.

Extending the Crew

Risk Manager agent: Run stress tests for -3%, -5%, -10% market moves across the watchlist
Portfolio Optimizer agent: Suggest position sizes based on conviction and correlation
Hierarchical process: A Research Director that delegates dynamically instead of fixed sequence

Start with two agents and add complexity only when you hit a real limitation. Multi-agent systems are powerful but harder to debug.

The complete working example is at github.com/grahammccain/chart-library-mcp in examples/crewai_tutorial.py.

Get your free API key at chartlibrary.io/developers and build your first research crew today. 24M patterns. 10 years. One API call.

How to Use an MCP Server for Stock Analysis with Claude

grahammccain — Mon, 06 Apr 2026 17:17:12 +0000

Model Context Protocol (MCP) is an open standard that lets AI assistants like Claude connect to external data sources and tools. Instead of copying data into a prompt, you install an MCP server that gives the AI direct access to a service's API.

Chart Library's MCP server gives Claude (and any MCP-compatible AI) access to 24 million pre-computed chart pattern embeddings, real-time regime data, sector analysis, and forward return statistics.

Installation: Two Commands

pip install chartlibrary-mcp

Get a free API key at chartlibrary.io/developers (200 calls/day free)
Add the server to Claude Desktop: Settings > Developer > MCP Servers > Add
Enter the command: chartlibrary-mcp --api-key YOUR_KEY
Restart Claude Desktop -- Chart Library tools appear in the tools panel

The MCP server also works with Cursor, Windsurf, and any editor or agent framework that supports MCP.

What the 19 Tools Do

You never call them directly -- Claude picks the right tool based on your question:

Pattern Intelligence (3 tools): Search for similar chart patterns, analyze ticker+date combos, get full intelligence reports with AI summaries
Market Context (4 tools): Market regime for SPY/QQQ, sector rotation rankings, crowding detection, scenario analysis
Discovery (3 tools): Today's top patterns, trending tickers, interesting setups
Portfolio & Alerts (4 tools): Add holdings, portfolio analysis, pattern alerts
Data & Utilities (5 tools): Ticker lookup, historical prices, API usage, accuracy stats

Example Conversation

You: "What does NVDA's chart look like right now? Anything interesting?"

Claude calls: get_intelligence(symbol="NVDA")

Claude: "NVDA's current intraday pattern closely matches 10 historical setups. The top match is AMD from August 2024 at 93% similarity. The average 5-day return is +1.6% with 7 of 10 matches moving higher."

You: "What's the broader market doing? Should I be worried?"

Claude calls: get_regime(), get_crowding()

Claude: "The current SPY regime most closely resembles March 2024 -- a slow grind higher on moderate volume. 8 of 10 similar periods saw gains over 10 days. However, the crowding detector shows elevated correlation across tech stocks, which historically precedes short-term pullbacks in about 40% of cases."

MCP vs. REST API: When to Use Which

Both access the same data. The difference is the interface:

Use Case	Best Choice
Conversational research	MCP
Automated trading systems	REST API
Building dashboards	REST API
Ad-hoc market analysis	MCP
Multi-agent workflows	Either

Many users keep the MCP server running in Claude Desktop for quick research while also calling the REST API from their trading scripts.

Get Started

pip install chartlibrary-mcp

The free tier gives you 200 calls per day -- more than enough for a full day of research. For more advanced use cases, check out the LangChain tutorial and CrewAI tutorial.

Chart Library: 24 million chart pattern embeddings. 10 years of history. Pattern intelligence for AI agents. chartlibrary.io/developers

Build a Stock Research Agent with LangChain + Chart Library in 20 Minutes

grahammccain — Mon, 06 Apr 2026 17:17:11 +0000

Most AI trading agents work with raw price data: OHLCV bars, moving averages, maybe some technical indicators. They can tell you what the price is, but not what it means.

Chart Library's API gives agents something they can't get anywhere else: pre-computed pattern similarity across 24 million embeddings spanning 10 years and 19,000+ symbols. Instead of asking "what's the price of NVDA?", your agent can ask "find the 10 most similar historical charts to NVDA right now and tell me how those patterns resolved."

Setting Up

You need three packages and two API keys:

pip install langchain langchain-openai chartlibrary

Get a free Chart Library API key at chartlibrary.io/developers (200 calls/day on the free tier)
Set your environment variables: CHART_LIBRARY_KEY=cl_... and OPENAI_API_KEY=sk-...

Note: You can swap OpenAI for Anthropic, Groq, Ollama, or any LangChain-compatible model. Just change the LLM initialization -- the tools stay the same.

Creating the Tools

LangChain agents work by selecting from a set of tools based on the user's question. Each tool wraps one or more API calls and returns a formatted string the LLM can reason over. We define five tools that cover Chart Library's core capabilities.

The chart_intelligence Tool

Here's the core tool that powers most agent interactions:

@tool
def chart_intelligence(symbol: str, date: str = "") -> str:
    """Get full pattern intelligence for a stock ticker.
    Returns the 10 most similar historical chart patterns,
    what happened after those patterns (1/3/5/10-day forward
    returns), and an AI-generated summary."""
    data = cl.intelligence(symbol, date=date or None, compact=True)
    # Format matches, forward returns, and summary
    # into a readable string for the LLM
    return formatted_result

The tool extracts the top 3 matches with similarity scores, forward return statistics (average return, win rate) for each horizon, and the AI-generated summary.

Market Regime and Sector Tools

Beyond individual stocks, agents need market context:

market_regime -- calls the /regime endpoint for SPY, QQQ, and all 11 S&P sector ETFs with historical pattern matching
sector_rotation -- sector momentum rankings
crowding_detector -- checks if many stocks are trading the same pattern (signals systematic risk)
scenario_analysis -- stress-tests a stock against a hypothetical market move

Building the Agent

With the tools defined, assembling the agent takes about 10 lines:

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
tools = [chart_intelligence, market_regime,
         crowding_detector, scenario_analysis,
         sector_rotation]

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(
    agent=agent, tools=tools,
    verbose=True, max_iterations=5
)

Example Conversation

Here's what a real session looks like:

User: "What does NVDA's chart look like right now? How did similar patterns play out?"

Agent calls: chart_intelligence("NVDA")

Agent: "NVDA's current chart pattern matches 10 historical patterns with high similarity. The top match is AMD from 2023-08-14 at 94% similarity. Looking at what happened after these patterns: over 5 days, the average return was +1.8% with 7 of 10 matches moving higher. Over 10 days, the average was +2.4% with 6 of 10 positive."

User: "What about the broader market? Is there anything concerning?"

Agent calls: market_regime(), crowding_detector()

Agent: "SPY's 30-day change is at +3.2%, with 8 of 10 similar historical regimes seeing positive 10-day returns. However, the crowding detector is showing elevated readings -- many stocks are trading in lockstep, which historically signals higher correlation risk."

Extending the Agent

The five tools above cover the core use cases, but Chart Library's API has more endpoints you can wrap:

Alerts: Let the agent set up pattern alerts ("tell me when a chart similar to AAPL 2024-01-15 appears again")
Portfolio analysis: Connect the agent to a user's portfolio for nightly pattern monitoring
Historical backtest: Run pattern-based backtests to validate strategies
Multi-timeframe: Search across 5min, 15min, 30min, 1hr, or multi-day windows

The full tutorial code is on GitHub at github.com/grahammccain/chart-library-mcp in the examples/ directory.

What's Next: Multi-Agent Workflows

A single agent is useful. The next level is multi-agent workflows where specialized agents collaborate -- a Pattern Analyst, a Regime Strategist, and a Risk Manager that discuss, debate, and produce a unified research brief.

Chart Library's MCP server (pip install chartlibrary-mcp) works with any MCP-compatible agent framework -- including Claude Desktop, Cursor, and Windsurf.

Get a free API key at chartlibrary.io/developers and start building. 24 million chart pattern embeddings, 10 years of history, one API call.