DEAD INTERNET：開源數碼考古平台，重探消失的網絡

An Open-Source AI Digital Archaeology Platform | Local AI | Ollama | React | FastAPI

What happens when a website disappears?

A personal homepage that someone spent years building. A forum where people once shared ideas. A small community that slowly stopped posting. A software project that was abandoned halfway through.

The internet moves forward, but not everything gets preserved.

Sometimes, all that remains are fragments: old HTML files, text backups, disconnected conversations, timestamps, and incomplete documentation.

We wanted to explore what it would look like to investigate those fragments instead of simply reading them.

That's how DEAD INTERNET came to life.

What We Built

DEAD INTERNET is an open-source, local-first digital archaeology platform that turns preserved digital documents into interactive investigations.

Instead of treating archived files as disconnected pieces of text, the platform lets you explore them, discover clues, connect evidence, reconstruct timelines, and investigate what might have happened.

It combines deterministic evidence discovery with an optional local AI investigator powered by Ollama.

The idea is simple:

Don't just browse the remains of the internet. Investigate them.

Exploring The Archives

The platform includes four fictional investigations, each with interconnected documents, clues, timeline events, and a predefined solution.

1. The Last Homepage

A personal website preserved through an old backup. Explore its pages, metadata, and fragments to reconstruct the story behind the abandoned homepage.

2. The Empty Forum

A once-active online community with fragmented discussions and disconnected conversations. Piece together what happened through its surviving posts.

3. The Lost Project

An abandoned software project with documentation, development notes, and incomplete records. Investigate the decisions and events that led to its disappearance.

4. The Forgotten Blog

A collection of disconnected blog posts with missing context. Follow references and timestamps to understand the story behind them.

Each archive is designed as a compact, playable mystery rather than a collection of unrelated sample documents.

Inside An Investigation: The Forgotten Blog

One of the sample investigations is called The Forgotten Blog.

The Paper Moon blog survives as three entries and an export note. At first glance, the recovered files seem to predict a station fire.

But is that actually what happened?

The investigation asks:

Did Paper Moon predict a real fire, or does the recovered ordering hide a different explanation?

Examining The Recovered Documents

The Archive Explorer provides a preserved-file browser alongside a read-only document viewer.

Screenshot 1: The Recovered Clock Entry

The Forgotten Blog - First Recovered Entry

The first document, 01-the-clock.md, introduces the mysterious station incident through a story dated June 9, 1987, but published in February 2005.

Screenshot 2: Following The Next Document

The Forgotten Blog - Second Recovered Entry

The second entry, 02-the-platform.md, adds an important detail: the character had already taken the last bus. It also includes an author's note explaining that the station name was borrowed from an old photograph and the characters were fictional.

The second document changes how the first entry should be interpreted.

That's the kind of interaction we wanted to build: a small collection of preserved documents that gradually reveals a larger story.

How The Investigation Works

The experience follows a simple investigation workflow.

1. Explore The Archive

Select an investigation from the archive library. Browse preserved documents, inspect their contents, and examine available metadata.

2. Discover Clues

Collect predefined evidence from documents. Each discovered clue connects to supporting artifacts and contributes to the investigation.

3. Connect The Evidence

The Clue Board brings discovered evidence together so you can understand relationships between different documents.

4. Reconstruct The Timeline

Relevant events appear chronologically with references to their supporting artifacts.

5. Ask The AI Investigator

Ask questions about the archive, explore possible relationships, identify contradictions, and request evidence-based summaries.

6. Generate An Investigation Report

Review your findings and export the investigation as a Markdown report.

The predefined solutions are independent of AI-generated interpretations. Collecting evidence, completing investigations, and accessing fictional ground-truth solutions do not depend on Ollama.

Investigate Your Own Archives

We also wanted DEAD INTERNET to work beyond the four sample mysteries.

That's where My Own Archive comes in.

Users can import their own preserved digital documents:

• HTML and HTM files
• TXT files
• Markdown files
• ZIP archives containing supported documents

The platform extracts readable text and available metadata while preserving original filenames.

Imported archives use the same investigation engine as the predefined cases.

Uploaded content is treated as evidence, not executable code. HTML is displayed as escaped source text rather than a live webpage.

One important distinction: imported archives provide document observations, not fabricated mystery solutions. The platform investigates what is actually present in the supplied files.

How We Built It

We wanted the architecture to remain modular and relatively lightweight. The same investigation engine needed to work with both fictional sample archives and user-imported documents.

Technology Stack

Architecture

The application follows a straightforward architecture:

React + Vite Frontend
        |
        v
Centralized API Client
        |
        v
    FastAPI Backend
        |
        |---- Archive Service
        |         |
        |         v
        |       SQLite
        |
        |---- File Ingestion
        |
        |---- Clue Engine
        |
        |---- AI Investigator
                  |
                  v
                Ollama
              Local Model

The backend is divided into dedicated modules:

• main.py handles API routes.
• archive_service.py manages archives, artifacts, and investigation state.
• file_ingestion.py validates and extracts uploaded documents.
• clue_engine.py handles deterministic clues, timelines, and reports.
• ai_investigator.py manages local model interactions.
• schemas.py defines request and response structures.

This separation keeps the investigation logic independent of the frontend and makes it easier to extend the platform with additional archive types.

Bringing AI Into Digital Archaeology

One of the central parts of DEAD INTERNET is its local AI investigator.

We chose Ollama because we wanted developers to experiment with open-weight language models without requiring hosted AI APIs or paid API keys.

The application communicates with Ollama locally through its generation endpoint.

The AI Investigator supports:

• Potential clue extraction.
• Identifying relationships between documents.
• Detecting possible contradictions.
• Answering questions about archived content.
• Suggesting chronological events.
• Generating investigation summaries.

Evidence Before Intelligence

An AI model can produce a convincing explanation even when the source documents don't support it. That's particularly dangerous in an investigation tool.

So we designed DEAD INTERNET to distinguish three things:

Facts: Information directly supported by supplied documents.

Hypotheses: Possible interpretations and relationships that require further investigation.

Unknowns: Questions that the available evidence cannot answer.

AI responses include source filenames and relevant excerpts. The backend validates citation filenames, artifact scope, and quoted text against the supplied evidence.

AI-generated interpretations do not automatically become verified clues or timeline events.

If Ollama is unavailable, the application reports the failure instead of pretending that an investigation succeeded.

The deterministic investigation workflow continues to work without AI.

Handling Uploaded Archives Safely

Allowing users to upload old websites and documents introduces another challenge: untrusted files.

We wanted the application to treat uploaded content as evidence, not executable code.

Some of the precautions include:

• File-type and size validation.
• Limits on document count and total upload size.
• ZIP path-traversal protection.
• Rejection of encrypted, nested, and unsupported archive members.
• In-memory ZIP processing rather than extracting arbitrary files to disk.
• HTML displayed as escaped source text rather than an executable webpage.
• Separate investigations with archive-scoped artifact access.

Uploaded content stays in the locally configured SQLite database. When AI analysis is requested, relevant excerpts are sent to the configured Ollama service.

This is a local-first design, not a claim of complete security. The current MVP does not include authentication, encryption at rest, or multi-user access controls.

What Makes This Project Interesting?

We didn't want DEAD INTERNET to become another AI wrapper where the entire experience depends on a model generating text.

The investigation engine and the AI investigator have different responsibilities.

The deterministic system manages evidence, progress, predefined solutions, and reports.

The AI helps explore possible interpretations of the available documents.

That distinction means users can still complete investigations without installing a model.

It also makes the project easier to extend without turning every feature into an AI-generated response.

Testing And Verification

The project includes a focused backend test suite covering:

• Archive and artifact retrieval.
• File validation and safe ZIP extraction.
• Clue discovery and timeline construction.
• Independent investigation state.
• AI evidence validation and missing citations.
• Ollama connection failures and timeouts.
• Investigation report generation.

The verification commands are:

.\.venv\Scripts\python.exe -m pytest tests -q

npm.cmd --prefix frontend run build

The Ollama failure tests use mocked transport, so they don't require a running model. A separate live-model smoke test is needed to evaluate actual inference quality.

What's Next?

There is still plenty of room to take this further.

Some areas we'd like to explore:

• More advanced document parsing and metadata extraction.
• Better retrieval across larger collections of documents.
• Stronger claim-level evidence verification.
• More sophisticated relationships between artifacts.
• Archive backup, deletion, and retention controls.
• More sample investigations with richer narratives.
• Improved evaluation of local models on evidence-based questions.

The goal is to make digital archaeology more interactive while keeping the underlying evidence inspectable.

🤝 Team Credits

DEAD INTERNET is a collaborative project built with my friend *@abirami_prabhakar *.

We worked together on bringing local AI inference, preserved digital archives, evidence-based investigations, and an interface that turns exploring forgotten internet fragments into something interactive.

🔗 Project Repository: https://github.com/abirami-prabhakar/Dead-Internet

The project is open source under the MIT License. Contributions, feedback, and ideas for exploring digital archaeology are welcome.

Built with React, FastAPI, SQLite, Ollama, and a little curiosity about the parts of the internet we leave behind.

🕸️