DeepAnalyze

An autonomous data-science assistant for analyzing diverse data sources and producing professional reports.

Stars
★ 4.8k
Last updated
6d ago
License
MIT
Primary language
Python

At a glance

How it runs
Library / SDKWeb appSelf-hosted service
Works with
Portable with changes
Cost
Free, no paid service needed
Setup effort
High · needs real infrastructure
You'll need
Python 3.12PyTorchTransformersvLLM >=0.8.5Node.jsJupyterLabShell / CLINetwork accessLocal filesystemMCP Server
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

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.

  1. An analyst needs to place several CSV and Excel files in one workspace and produce an integrated report for business stakeholders.
  2. A researcher needs to investigate a mixed collection of database data, JSON, XML, YAML, text, and Markdown as an open-ended data-research task.
  3. A data-science team working in JupyterLab wants analysis narrative, generated code cells, and code execution in a notebook-oriented interface.
  4. An internal-platform developer needs OpenAI-style file-upload and chat-completion endpoints around a locally deployed DeepAnalyze-8B service.
  5. 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?

Pros
  • 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.
Limitations
  • 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?

FollowAgents source review · FARS-2.1
Major gaps
42/ 100 5-point scale 2.1 / 5
Trust 8/29
Reliability 5/14
Adaptability 9/18
Convention 10/18
Effectiveness 7/13
Verifiability 3/8
Why each dimension lost points
Trust8 / 29 · 1.4/5

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.

Reliability5 / 14 · 1.8/5

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).

Adaptability9 / 18 · 2.5/5

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).

Convention10 / 18 · 2.8/5

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).

Effectiveness7 / 13 · 2.7/5

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).

Verifiability3 / 8 · 1.9/5

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).

Risks and how to mitigate them
  • 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.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision afc697a11675
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/deepanalyze.svg)](https://followagents.com/en/agents/deepanalyze)
<a href="https://followagents.com/en/agents/deepanalyze"><img src="https://followagents.com/badge/deepanalyze.svg" alt="FARS review"></a>

FAQ

Is an API key required for local deployment?
The documented local vLLM, WebUI, CLI, and Python flows do not list an API key as a prerequisite. The project also offers an API-key service that requires an application.
What hardware does it need?
The documentation provides recommendations for 16GB, 24GB, 40GB, and 80GB GPU memory. For less than 24GB, it recommends a 4-bit quantized model with FP8 KV cache.
What data can it work with?
The repository explicitly lists databases, CSV, Excel, JSON, XML, YAML, TXT, and Markdown, and says a task can include multiple data sources.
Can it be integrated into an existing application?
It can expose OpenAI-style file-upload and chat-completion endpoints through API/start_server.py. The integrating team remains responsible for its own authentication, deployment, and application-side calling logic.
Was this page helpful?
View on GitHub ↗ Install ↓