DeepAnalyze
An autonomous data-science assistant for analyzing diverse data sources and producing professional reports.
- Source repo
- ruc-datalab/DeepAnalyze
- Stars
- ★ 4.6k
- Last updated
- 1d ago
- License
- MIT
- Primary language
- Python
- FA score
- 35/100 · Major gaps
At a glance
- Works with
- Portable with changes
- You'll need
- Typical use
- An analyst needs to place several CSV and Excel files in one workspace and produce an integrated report for business stakeholders.
- Main limitation
- Local operation depends on DeepAnalyze-8B, vLLM, PyTorch, and Transformers, with GPU-memory-dependent choices for quantization, context length, and FP8 KV cache.
- Source review
- 35/100 · Major gaps 4 safety controls not found
What does this agent do, and when should you use it?
DeepAnalyze is an 8B-parameter agentic LLM project for autonomous data science, spanning data preparation, analysis, modeling, visualization, and report generation. It is presented for structured, semi-structured, and unstructured sources including databases, CSV, Excel, JSON, XML, YAML, TXT, and Markdown. The repository exposes a DeepAnalyzeVLLM Python interface, WebUI, WebUI v2, JupyterUI, CLI, and an OpenAI-style HTTP API. Its documented deployment boundary is a locally served DeepAnalyze-8B model via vLLM, with users supplying a workspace and data files. The documented output is a data-science report with reasoning and analysis results; the example notes that reports can be rendered as PDFs.
After DeepAnalyze-8B is served with vLLM, a caller passes an instruction, file information, and a workspace to DeepAnalyzeVLLM.generate(prompt, workspace=workspace). The documented flow explores multiple files, performs data preparation, analysis, modeling, and visualization, then returns results including reasoning and a data-science report. The WebUI accepts uploaded data in a browser. JupyterUI converts <Analyze>, <Understand>, and <Answer> into Markdown cells, converts <Code> into code cells, and executes them as <Execute>. API/start_server.py exposes /v1/files for uploads and /v1/chat/completions for chat requests, while the CLI supports file uploads and streamed responses.
- An analyst needs to place several CSV and Excel files in one workspace and produce an integrated report for business stakeholders.
- A researcher needs to investigate a mixed collection of database data, JSON, XML, YAML, text, and Markdown as an open-ended data-research task.
- A data-science team working in JupyterLab wants analysis narrative, generated code cells, and code execution in a notebook-oriented interface.
- An internal-platform developer needs OpenAI-style file-upload and chat-completion endpoints around a locally deployed DeepAnalyze-8B service.
- A command-line user needs to upload files and receive streamed analysis responses through either the English or Chinese CLI.
How do you install or deploy this agent?
For local deployment, create the documented Python environment and install dependencies: conda create -n deepanalyze python=3.12 -y, conda activate deepanalyze, and pip install -r requirements.txt. Download DeepAnalyze-8B, then serve it with vllm serve DeepAnalyze-8B. For the WebUI, run cd demo/chat/frontend && npm install && cd .. && bash start.sh, then open http://localhost:4000. For WebUI v2, run cd demo/chat_v2/frontend && npm install && cd .. && cp .env.example .env && bash start.sh; its documentation also describes Docker-based sandboxed code execution. The separately offered DeepAnalyze API-key service requires applying through the listed Google or Feishu forms.
How do you use this agent?
Once the model service is running, import DeepAnalyzeVLLM, create an instance, and call generate(prompt, workspace=workspace) with a task such as Generate a data science report. and the relevant file details. For the CLI, run cd API && python start_server.py in one terminal, then cd demo/cli && python api_cli.py in another; use python api_cli_ZH.py for Chinese. For HTTP use, upload a file to http://localhost:8200/v1/files, then send the returned file ID to http://localhost:8200/v1/chat/completions.
What are this agent's strengths and limitations?
- Covers a documented end-to-end data-science workflow rather than only chat or single-step code generation.
- Explicitly supports a broad set of file and data formats and multiple data sources in one task.
- Offers Python, browser, JupyterLab, CLI, and OpenAI-style API delivery modes.
- WebUI v2 explicitly documents Docker-based sandboxed code execution.
- Local operation depends on DeepAnalyze-8B, vLLM, PyTorch, and Transformers, with GPU-memory-dependent choices for quantization, context length, and FP8 KV cache.
- The repository recommends separate inference and training environments to avoid dependency conflicts, adding operational overhead.
- The WebUI requires npm-installed frontend dependencies, while JupyterUI depends on JupyterLab and a jupyter-mcp-server-based integration.
- The supplied material does not document failure handling, permission isolation details, or reliability measurements across deployment environments.
How does this agent compare with similar options?
The repository identifies DeepSeek-R1-0528-Qwen3-8B as a possible training base and also permits direct fine-tuning from DeepAnalyze-8B; DeepAnalyze adds data-science-oriented training, inference, and interaction components around that use case.
Key facts side by side with the most closely related agents.
| Agent | Source review | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|
| DeepAnalyze This agent | 35 · Major gaps | ★ 4.6k | 1d ago | Python | — |
| Business Analytics Agent | 60 · Some gaps | ★ 2.6k | 6d ago | JavaScript | OpenAI API |
| DATAGEN Research Assistant | 44 · Major gaps | ★ 1.8k | 7d ago | Python | OpenAI API · Claude API |
| FinRobot | 51 · Major gaps | ★ 8.1k | 12d ago | Jupyter Notebook | OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence shows: README describes data science tasks but does not mention least privilege or sandboxing; WebUI v2 supports Docker sandbox but not default or enforced. User confirmation not mentioned. Data flow transparency: README explains data upload and file handling but not data flow or storage. Sensitive data handling not mentioned. Dependency security: requirements.txt lists dependencies without version pinning or security audit. External effects: code execution may have side effects but no restrictions. Rollback not mentioned. Source attribution: README lists authors and institution but not verified. Deductions: lack of permission controls, user confirmation, sensitive data protection, dependency security, rollback, etc.
Evidence shows: README and code examples are consistent in task description, but no error handling or failure message details. Dependency availability: requirements.txt lists common libraries but without versions, affecting reproducibility. Failure messages: no error handling or user prompts. Deductions: lack of failure handling documentation and version pinning.
Evidence shows: README identifies target users (data scientists, developers) and multiple scenarios (data analysis, report generation). Capability boundaries: README mentions support for various data formats but no explicit limits. Trigger precision: triggered by natural language instructions but no precise trigger conditions. Environment fit: multiple deployment options (WebUI, CLI, Jupyter) but no system requirements. Deductions: capability boundaries and trigger conditions not precise.
Evidence shows: README is well-structured with installation, usage, and development guides. Install notes are detailed with dependencies and commands. Naming stability: model and API names consistent. Examples and FAQ: multiple examples but no FAQ. Known limitations: not explicitly listed. License: MIT. Versioning/changelog: news updates but no formal changelog. Maintenance responsibility: authors and contact clear. Deductions: missing FAQ, known limitations, and formal changelog.
Evidence shows: Output is a data science report renderable to PDF, practical. Marginal value: automated data analysis saves time but requires user deployment. Cost-benefit: requires GPU resources but no cost estimate. Deductions: insufficient cost-benefit analysis.
Evidence shows: README claims to be the first agentic LLM but no independent verification. Cross-source: provides arXiv paper and Hugging Face model but not cross-verified. Fact/inference separation: not clearly distinguished. Deductions: lack of independent verification and fact/inference separation.
- Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
- Not found in source: sensitive-data handlingUse dedicated, low-privilege, revocable API keys — never production credentials — and keep secrets out of logs.
- Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- The repository lacks security mechanisms such as least privilege, user confirmation, and sensitive data protection; strengthen when deploying.
- Dependencies are not version-pinned, affecting reproducibility and security.
- Code execution may have external effects; run in a sandboxed environment.