# Paper2Any: The Legacy Open-Source Tool That Became Nexus Office

> Paper2Any was a Python tool for turning academic papers and text into research figures, technical diagrams, and presentation slides. The repository now serves as an Apache-2.0 archive of that original codebase; the actively developed successor is Nexus Office, a hosted AI workspace for Office document creation that is not distributed here.

**OpenDCAI/Paper2Any** — Turn paper/text/topic into editable research figures, technical route diagrams, and presentation slides.

- Repository: https://github.com/OpenDCAI/Paper2Any
- Website: https://paper2any-studio.cpolar.cn/
- Stars: 2,797 · Forks: 196
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/opendcai-paper2any

## What Paper2Any Originally Did and Who It Was For

Paper2Any started as a tool to automate the production of research artifacts. Given an academic paper, a block of text, or a research topic, the system generated editable research figures, technical route diagrams, and presentation slides. Its audience was researchers who wanted to move from a written paper to a visual presentation or diagram without manually recreating each element.

The original workflow, as described in the repository README, routed input through an LLM agent that selected the appropriate tools, produced the output document, ran structural checks, and opened the result for editing. The agent kept conversation history, execution trace, source files, and deliverables in a single persistent workspace so follow-up edits could continue from the same context.

The README is explicit about the repository's current status: it is a legacy snapshot. The text reads, 'This repository preserves the original Apache-2.0 Paper2Any codebase, but it no longer receives new product features or architecture updates.' The repository has no GitHub releases.

## The Nexus Office Pivot: What Changed and What Did Not

Starting in mid-2026, the team rebuilt the product as Nexus Office, described in the README as 'the next-generation AI Office workspace from Paper2Any.' Nexus Office keeps the core idea of handing a document task to an agent, but shifts focus from academic paper workflows to everyday Office delivery: PowerPoint, Excel, Word, and AI visual composition.

The README publishes a comparison table that is worth reading before deciding which path to take:

| | This repository | Nexus Office |
|---|---|---|
| Positioning | Original paper-oriented Paper2Any codebase | AI-native Office workspace |
| Development status | Legacy snapshot | Actively developed hosted product |
| Source availability | Apache-2.0 source code here | Hosted implementation not distributed |

The Apache-2.0 license covers only the code in this repository. The hosted Nexus Office implementation is a separate product with separate terms. Teams evaluating the project should decide up front whether they need a self-hostable codebase (legacy Paper2Any) or a maintained hosted service (Nexus Office) before starting integration work.

## Architecture and Data Flow in the Legacy Codebase

The Python backend runs on FastAPI and includes several directories with distinct responsibilities: `dataflow_agent/` holds the LLM agent component (pip-installable as `dataflow-agent`), `fastapi_app/` contains the web API, `frontend-workflow/` holds the React interface, and `models/` stores downloaded model weights.

The backend depends on LangGraph (pinned to version 0.6.7 in pyproject.toml), LangChain, and a FAISS CPU index for retrieval. The full agent workflow from the README is:

```text
Goal + source files
        -> Agent chooses the Office and visual tools
        -> editable PPTX / XLSX / DOCX / PNG
        -> structural checks and visual review
        -> open, revise, and continue in the same Workspace
```

For image processing, the Dockerfile installs LibreOffice, Inkscape, wkhtmltopdf, and poppler-utils as system packages alongside Python dependencies. The SAM3 model handles interactive segmentation for click-to-cutout workflows, and RMBG-2.0 handles background removal. These models must be downloaded separately and mounted via the `models/` volume in the Docker Compose configuration.

## Deploying the Legacy Codebase with Docker

The repository includes a multi-service Docker Compose file. The backend service builds from the local Dockerfile, reads environment variables from `fastapi_app/.env`, binds to port 8000 by default, and mounts several local directories for outputs, models, data, and logs. The frontend can be added to the same Compose project or run separately.

The Docker Compose comments document the standard startup sequence:

```bash
docker compose up -d
```

The backend runs a health check against `/health` every 20 seconds with a 30-second startup period before the first check, so a few minutes of startup time is expected on first launch while models load. The backend container is configured with `restart: unless-stopped`, so it persists across host reboots.

For the CUDA-accelerated path (required for reasonable inference speed with SAM3), the Dockerfile accepts an `INSTALL_CUDA=1` build argument that installs the packages from `requirements-cu12.txt`. The non-CUDA path uses `requirements-paper.txt`, which installs CPU-only inference libraries. The environment variable `PAPER2ANY_RUNTIME_TMPDIR` controls where the backend writes temporary files and defaults to `/app/outputs/system/tmp` inside the container.

## Real Limitations of the Open-Source Snapshot

The most consequential limitation is that this codebase no longer tracks product development. The README states it receives no new architecture or feature synchronization. Any gap between what the snapshot does and what Nexus Office does will grow over time and is not documented.

A second limitation is the deployment complexity. The Docker image installs LibreOffice, Inkscape, wkhtmltopdf, and large model weights at build time. The Dockerfile fetches wkhtmltopdf from a GitHub release during the build step, which introduces an external dependency that can break builds if the URL changes. Teams running air-gapped deployments will need to pre-stage these downloads.

A third limitation is that interactive segmentation at production scale requires Docker and GPU hardware. The README notes that the click-to-cutout feature runs locally in the browser and does not consume image-generation credits, but the SAM3 checkpoint must be present on disk and the container needs enough GPU memory to load it alongside the main language model. The README does not document minimum GPU specifications.

The project's LangGraph version is pinned to 0.6.7 alongside langchain-core 0.3.76, langchain-openai 0.3.33, and related packages pinned at specific versions. LangGraph and LangChain release frequently, and these pinned versions may conflict with other packages in a shared Python environment. Using a dedicated virtual environment is strongly advisable. The pyproject.toml also separates optional dependencies into `paper`, `data`, and `dev` extras, but the main requirements-paper.txt installs the full set without this granularity, which inflates the image size regardless of which document types a deployment actually needs.

## License Scope and a Comparable Alternative

The Apache-2.0 license applies only to the code and assets in this repository. The README repeats this boundary explicitly in both the comparison table and a separate note: 'The Apache License 2.0 applies only to the code and assets distributed in this repository. It does not apply to the hosted Nexus Office implementation.' Teams that want to fork and modify the agent logic can do so under Apache-2.0; teams that want to use the hosted product are subject to its separate terms.

A comparable open-source alternative is Docling, an IBM Research project that also converts documents to structured formats for downstream use. Docling focuses on parsing and conversion rather than on agent-driven Office document generation, so it covers different ground: extracting content from existing documents rather than creating new ones from research inputs. Unlike Paper2Any, Docling is actively maintained and handles a wider range of input formats without requiring a GPU.

The last push to Paper2Any was on 2026-08-31, and the repository explicitly describes itself as a legacy snapshot with no ongoing architecture work. There have been no GitHub releases at any point.

## Conclusion

Engineers who need to reproduce figures or slides from the original Paper2Any research pipeline can use this Apache-2.0 codebase with Docker. Teams looking for an actively developed product should go to Nexus Office, which is not covered by this license. Before deploying the legacy code, verify that the required local models (RMBG-2.0, SAM3) and system packages (LibreOffice, wkhtmltopdf, LaTeX toolchain) are available in the target environment, since the Docker image build is non-trivial.

## FAQ

### Can Paper2Any still be used to generate slides from a research paper?

The legacy codebase supports this workflow, but the README describes it as a historical snapshot that no longer receives feature updates. Deploying it requires Docker, SAM3 model weights, and system packages including LibreOffice and wkhtmltopdf. The README directs users who want an active product to Nexus Office.

### Does the Apache-2.0 license cover Nexus Office as well as the repository code?

The README states the Apache-2.0 license applies only to the code and assets in this repository. The hosted Nexus Office implementation is not distributed here and is not covered by that license.

### What GPU or hardware is required to run the local Paper2Any backend?

The README does not document minimum GPU specifications. The Dockerfile supports an optional CUDA path activated with the INSTALL_CUDA=1 build argument, using packages from requirements-cu12.txt. The SAM3 segmentation model and the background-removal model both require GPU memory, but exact requirements are not stated in the available documentation.

## Sources

- [Issues](https://github.com/OpenDCAI/Paper2Any/issues)
- [License: Apache-2.0](https://github.com/OpenDCAI/Paper2Any/blob/main/LICENSE)
- [OpenDCAI/Paper2Any on GitHub](https://github.com/OpenDCAI/Paper2Any)
- [Project website](https://paper2any-studio.cpolar.cn/)
- [README](https://github.com/OpenDCAI/Paper2Any/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/opendcai-paper2any