DeepAnalyze
An autonomous data-science assistant for analyzing diverse data sources and producing professional reports.
- Source repo
- ruc-datalab/DeepAnalyze
- Stars
- ★ 4.8k
- Last updated
- 6d ago
- License
- MIT
- Primary language
- Python
- FA score
- 42/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changes
- Cost
- Free, no paid service needed
- Setup effort
- High · needs real infrastructure
- 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.
- Not a fit if
- Users without a GPU or with under 16GB of VRAM
- Teams wanting a turnkey service without deploying vLLM and the model themselves
- Those who need a vendor-hosted cloud rather than local deployment
- Source review
- 42/100 · Major gaps 2 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 | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| DeepAnalyze This agent | 42 · Major gaps | Library / SDKFree | ★ 4.8k | 6d ago | Python | — |
| Business Analytics Agent | 61 · Some gaps | Desktop appFree + model costs | ★ 2.6k | 2d ago | JavaScript | OpenAI API |
| Seal Report | 54 · Major gaps | Desktop appFree | ★ 1.6k | 2d ago | C# | OpenAI API · Claude API |
| DATAGEN Research Assistant | 45 · Major gaps | CLIFree + model costs | ★ 1.8k | 14d ago | Python | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The README and guides indicate that data may be uploaded through a local deployment or API and show a Bearer API key, providing limited data-flow clues (data_flow_transparency=1). They do not describe storage, retention, access controls, or sensitive-data handling (sensitive_data_handling=0). API examples require the user to provide files and instructions, so user_confirmation=1; autonomous analysis, permissive CORS, and unspecified sandbox details do not establish least privilege or controlled external effects (least_privilege=1, external_effects=1). No execution rollback or recovery mechanism is shown (rollback=0). The dependency list names packages but has no version lock or security policy (dependency_security=1). The README names authors, institutions, model, and dataset sources (source_attribution=2); the publisher's registry identity is unverified and earns no additional credit.
The README provides several entry points, requirements, configuration examples, and stop scripts, while the FAQ notes Windows/vLLM constraints. However, the Gradio deployment described by the API guide is not corroborated by the supplied source files for the main README path, and the code sample only shows a server entry point (self_consistency=1). Dependencies are only partly versioned, and deployment relies on vLLM, model downloads, and API services without a sufficient availability or compatibility matrix (dependency_availability=1). The FAQ addresses a few problems, but the shown API entry point provides no error-handling details (failure_messages=1).
The materials address data-analysis users, developers, and training/evaluation users, with CSV, spreadsheets, JSON, text, web, CLI, and Jupyter scenarios (audience_and_scenarios=2). Broad claims such as handling any task or data source are not paired with clear capability boundaries or validation limits (capability_boundaries=1); guidance on when the product is suitable or unsuitable is limited (trigger_precision=1). Local, API, and container-related routes are described, with WSL/Docker advice for Windows and GPU-memory recommendations (environment_fit=2).
The README organizes demos, quick start, API, training, and contribution material, with separate API guides, FAQs, and a license (information_architecture=2). Installation and launch commands, dependencies, and GPU-memory recommendations are fairly concrete, but version pins, deployment prerequisites, and integrity guidance for external downloads are limited (install_notes=2). The product is presented through WebUI, WebUI v2, JupyterUI, CLI, and Gradio routes; some guides depend on external archives, reducing naming and entry-point stability (naming_stability=1). Multilingual examples and FAQs exist but remain narrow (examples_and_faq=2). Windows/vLLM and Chinese-font issues are documented, while other model and data limitations are not (known_limitations=1). The MIT license is complete (license=3). Dated news provide some update history, but no version tied to this revision or compatibility policy is shown (versioning_changelog=1). Authors and contribution guidance are named, but maintenance responsibility and support commitments are unclear (maintenance_responsibility=1).
The stated outputs include analysis reports, visualizations, and downloadable files, and an example shows an analyst-oriented report format (output_usability=2). Combining data analysis, code execution, research, and reporting into one data-task workflow indicates plausible marginal value (marginal_value=2); cost-benefit guidance is limited to GPU memory and deployment options, without operating cost, latency, or resource tradeoffs (cost_benefit=1).
The README links some claims to a paper, model, dataset, examples, and deployment commands, but claims such as 'first' and 'any' are not directly substantiated in the supplied material (claim_traceability=1). The README, API guides, FAQs, startup code, and configuration snippets offer limited cross-checks; differing deployment paths and sampled source coverage constrain corroboration (cross_source_corroboration=1). Examples separate commands, expected output, and product descriptions, but the sample report and capability claims are not clearly labeled as measured results or illustrations, so fact and inference are weakly separated (fact_inference_separation=1).
- 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: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- Before uploading files to the online API, confirm data authorization and the service's storage, retention, and access policies; the materials do not describe sensitive-data safeguards.
- Local deployment involves vLLM, model downloads, and substantial GPU memory; check configuration against your environment, as the materials provide no operating-cost or performance guarantees.
- Broad capability claims and the sample report are not evidence of independently verified correctness.
FAQ
Is an API key required for local deployment?
What hardware does it need?
What data can it work with?
Can it be integrated into an existing application?
Thanks — we use this to improve the page.