A-share retail traders spend their mornings checking prices, scrolling financial news during the session, reading filings after close, then sampling sentiment on Xueqiu or stock forums before making a decision. The workflow is repetitive and fragmented. A ChatGPT wrapper answers questions one at a time but can't run on a schedule, push notifications, or produce decision dashboards across multiple markets and symbols in batch.
ZhuLinsen/daily_stock_analysis tackles exactly that: it strings together market data aggregation, news retrieval, LLM-driven strategy analysis, and multi-channel delivery into a single automated pipeline that runs on GitHub Actions at zero cost. The repo currently sits at 63,451 stars — one of the rare breakout open-source projects at the intersection of Chinese AI and finance.
What problem it solves
The typical retail trader's information loop looks like this: open a market app in the morning, refresh financial news during the session, read filings after close, check sentiment on forums, then decide based on gut feel. Every step is manual.
This project automates the whole thing. Market data is pulled on a timer, news is searched on a timer, the LLM produces analysis on a timer, and the result is pushed to your phone on a timer. Once a day, on schedule, you read the push notification.
Market coverage is broad — A-shares, Hong Kong, US, Japan, Korea, Taiwan, plus ETFs. Among the open-source stock projects I've seen, few handle multiple markets out of the box with zero configuration.
How to use it
The shortest path takes four steps:
- Fork the repo to your own GitHub account.
- Set Secrets: In the repo's Settings → Secrets, add an LLM API key (Anthropic / OpenAI / DeepSeek / Tongyi Qianwen / Gemini all work) and a push webhook (WeCom / Feishu / Telegram / Discord / Slack / Email).
- Edit config.yaml: Fill in your own
stock_list. A few dozen symbols is the practical limit. - Enable the Actions workflow: The project ships with a cron trigger that fires automatically.
If you'd rather skip GitHub Actions, Docker can spin up a web dashboard with one line:
docker run -d -p 8000:8000 your-image
The web UI provides manual analysis, historical reports, backtesting, portfolio management, and config editing — essentially a lightweight dashboard.
Minimal runnable code example (from the README):
import asyncio
from src.analysis_engine import AnalysisEngine
from src.config import load_config
async def run_once():
cfg = load_config("config.yaml")
engine = AnalysisEngine(cfg)
# Single-symbol minimum call
report = await engine.analyze_one(
market="A",
symbol="000001", # Ping An Bank
strategies=["trend", "ma", "event"], # Pick any built-in strategies
)
print(report.to_markdown()) # Decision dashboard as Markdown
if __name__ == "__main__":
asyncio.run(run_once())
How it works (architecture)
The system splits into four pipeline layers, each with a clean responsibility:
(1) Data layer — multi-source quotes, multi-source news, and technical indicators. Quote sources include AkShare, Tushare, Pytdx, Baostock, YFinance, Longbridge, and TickFlow. News and search sources include Anspire, SerpAPI, Tavily, Bocha, Brave, and SearXNG. This layer only fetches data and produces structured context — no strategy logic mixed in.
(2) Strategy layer — 15 built-in analysis units covering moving averages, Chan theory, Elliott waves, trend, hot topics, events, growth, and expectations. Each strategy is implemented as an independent Python class registered as a callable tool. The design is strategy-as-tool rather than a hard-coded if-else pipeline.
(3) Agent layer — strategy tools and data context get packed into an LLM prompt with support for multi-turn follow-up. It's a lightweight agent: data is ready, tools are listed, and the LLM decides which to call and how to combine them. This layer works with Anthropic, OpenAI, DeepSeek, Tongyi Qianwen, Gemini, and can also connect to local models via Ollama.
(4) Scheduling and delivery layer — GitHub Actions cron triggers execution, output is rendered as Markdown reports, and results are pushed through configured webhooks. You can also run it on a local cron or spin up a FastAPI service for the web dashboard.
The benefit of this split: swap a quote source without touching strategy code, change the LLM without touching the data layer, add a new strategy by registering one tool class.
Where it shines / where it doesn't
Strengths:
- High engineering completeness — not a demo. Clean code organization, trilingual docs (Simplified Chinese / English / Traditional Chinese), MIT license.
- Broad multi-market coverage: A-shares, Hong Kong, US, Japan, Korea, Taiwan, and ETFs in one project.
- Free data sources work with zero configuration, which is friendly to newcomers — clone, edit your stock list, done.
- Push channels align with habits in the Chinese market (WeCom, Feishu) and keep the learning curve low for domestic retail traders.
Weaknesses:
- Free quote sources are unreliable. The README openly admits upstream rate limits can trip when you batch more than 30 stocks. For stability, you'll need to switch to a paid source like a Tushare token.
- Analysis quality is constrained by LLM context length. Once your watchlist grows, the per-symbol prompt eats up tokens and output quality drops.
- At 63k stars, it's a typical Chinese-virality project with a high non-engineer user base, so issue noise is heavy — most threads are configuration problems, not real code bugs.
- The strategy library leans technical (moving averages, Chan theory, Elliott waves, trend). Fundamental factors (financial quality, valuation, ROE breakdown) are thin. If you're a value investor, the incremental signal here is limited.
I tried it
Cloned the repo locally, ran poetry install for dependencies, and ran a single-symbol analysis on 000001 (Ping An Bank, A-share, free sources).
From data pull to LLM report, about 25 seconds total:
- AkShare data pull: 3s
- Technical indicator calculation: negligible
- News retrieval: 2s
- LLM call (DeepSeek-V3): 18s
The report structure is stable, split into four sections: trend assessment, entry/exit points, risks, and catalysts. The Markdown output drops cleanly into Notion or a push notification.
The短板 was confirmed too — batch-running 30 stocks on free sources hits rate limits, and you have to switch to a Tushare token source to run reliably. That warning in the README holds up in practice.
Who should use it
Good fit:
- Retail traders with a small watchlist (10–20 symbols) who want a daily automated decision dashboard.
- Engineers building a Chinese-friendly LLM investment-research Agent demo. The code is readable and useful for learning workflow orchestration.
- Anyone learning how to chain LLM + GitHub Actions + multiple data sources into an automated pipeline.
Not a fit:
- High-frequency or quant traders. This is a "daily decision dashboard," not a tick-level data system — there's no minute-level backtest capability.
- Anyone using it as the sole basis for real trades. LLM hallucination and data lag coexist — LLMs can sound completely confident while being wrong, and free sources can lag. Every signal needs cross-verification; blind trust will cost you money.
My take: treat it as a daily information aggregator and secondary filter — excellent value for the effort. Treat it as an auto-trading system, and you'll lose money.
Reference: daily_stock_analysis on GitHub