I Built an AI Séance to Bring Dead Codebases Back to Life 👻

What if you could have a conversation with a forgotten software project? Meet Repo Séance — an open-source AI-powered software archaeology assistant that helps developers explore, understand, and revive abandoned codebases.

What I Built

Every abandoned software project leaves something behind.

A collection of source files, undocumented design decisions, outdated dependencies, forgotten functions, and sometimes an entire application whose original developer is no longer available to explain how it works.

Understanding such projects can be surprisingly difficult.

You open a repository, navigate through dozens or hundreds of files, search for functions, trace dependencies, and try to reconstruct the original developer's thinking.

I wanted to explore a different approach.

What if we could simply have a conversation with a forgotten codebase?

That question inspired Repo Séance.

Repo Séance is an AI-powered software archaeology assistant that analyses existing software repositories and allows developers to investigate them through a conversational interface.

Users can import a public GitHub repository or upload a ZIP archive. The application examines the repository, indexes its source files, identifies programming languages, organizes relevant code segments, and makes the repository accessible through an AI-powered question-and-answer interface.

Instead of manually navigating an unfamiliar project, developers can ask questions about its implementation and receive explanations grounded in the available source-code context.

The objective is not simply to summarize code.

It is to recover the knowledge hidden inside forgotten software.

What Repo Séance can do

• Import public GitHub repositories and ZIP archives.
• Analyse repository structure and identify programming languages.
• Index source files and organize code into meaningful chunks.
• Browse repository files through an integrated source browser.
• Ask questions about the actual implementation.
• Retrieve relevant source-code context for AI-generated explanations.
• Display source references alongside responses.
• Generate a structured Markdown repository resurrection report.

The name represents the idea behind the project:

• The repository is the forgotten past.
• The Ghost is the AI assistant.
• The Séance is the conversation between the developer and the codebase.
• The resurrection report is the knowledge we bring back to life.

Demo

Live Application: https://ai-s-ance.onrender.com/

GitHub Repository: https://github.com/AnuragkGithub/AI-S-ance

The application demonstrates the repository-import workflow, source-code exploration, conversational interaction, and report generation.

Note: The current live AI demonstration depends on my MacBook Air running Ollama and maintaining its connection to the deployed application. The AI endpoint may therefore be unavailable when the local machine or tunnel is offline.

How I Built It

Repo Séance follows a modular architecture that separates repository ingestion, source-code processing, retrieval, AI interaction, and the user interface.

The application is built around four main stages.

1. Repository ingestion

The first stage accepts a public GitHub repository or an uploaded ZIP archive.

The backend retrieves or extracts the repository contents and prepares the files for analysis.

It filters the files that should not be included in the source index and collects relevant repository information.

2. Source-code analysis and indexing

Once the repository is available, the application examines its structure.

It identifies programming languages, discovers source files, and divides relevant content into manageable chunks.

These chunks are associated with their original file paths so that the application can retrieve and present relevant source references when answering questions.

3. Context-based question answering

This is the central feature of Repo Séance.

A developer can ask questions such as:

• What is the overall architecture of this repository?
• Which file contains the main application entry point?
• How does authentication work?
• Where is the database connection established?
• Which modules are responsible for processing user requests?
• What happens when a particular function is called?

The retrieval component searches the indexed repository content using keyword-based matching and selects relevant source-code context.

That context, together with the developer's question, is passed to the language model.

The model generates an explanation based on the retrieved information rather than relying only on general programming knowledge.

4. Repository resurrection report

Understanding individual files is useful, but developers also need an overall picture of an unfamiliar project.

Repo Séance therefore includes a report-generation feature that produces a structured Markdown summary of the repository.

The report helps developers understand the project structure, important components, and potential areas requiring further investigation.

Technology Stack

The project uses the following technologies:

Component	Technology
Frontend	HTML, CSS, JavaScript
Backend	Python, FastAPI
HTTP communication	Python Requests
AI runtime	Ollama
Language model	Qwen 2.5 Coder 7B
Repository ingestion	GitHub repository import and ZIP extraction
Source analysis	Python-based file and source processing
Retrieval	Keyword-based source-code retrieval
Deployment	Render
AI inference environment	Local Ollama server on macOS

Open-weight AI and local inference

One of the important design decisions was to experiment with an open-weight language model instead of depending entirely on proprietary AI APIs.

Repo Séance currently uses:

Qwen 2.5 Coder 7B through Ollama.

Ollama provides a straightforward way to run the model and communicate with it through an API.

The model receives the user's question along with relevant repository context and generates a response.

For the live demonstration, the FastAPI application is deployed on Render, while Ollama runs on my MacBook Air. A tunnel connects the deployed backend to the local inference server.

This setup allowed me to experiment with model inference without immediately requiring a dedicated GPU server.

The model runtime can also be changed independently of the repository-ingestion and frontend components.

Why Does Open Innovation Matter?

For Repo Séance, open innovation is more than a technology preference.

It is closely connected to the problem we are trying to solve.

Software repositories contain implementation details, architectural decisions, configuration information, and sometimes sensitive business logic.

Developers should have flexibility and control over how AI systems interact with their code.

Using an open-weight model and an inspectable development stack provides several advantages.

1. Model flexibility

Developers can experiment with different open-weight models and select the ones that best suit their hardware and code-analysis requirements.

2. Greater control over inference

Running Ollama locally provides an alternative to sending every inference request to a proprietary model API.

3. Customization

The model interaction, prompts, retrieval logic, and repository-analysis pipeline can be inspected and modified.

4. Reduced dependency on proprietary AI services

The project does not require a proprietary per-token AI API for its current inference workflow.

5. Community-driven development

An open-source project can be extended through contributions, additional language support, improved retrieval strategies, and better repository-analysis capabilities.

The current demonstration uses a hosted application backend connected to local inference. It should not be considered a fully private, end-to-end local deployment yet.

That distinction is important because open innovation should also mean being transparent about the architecture and its limitations.

My Agent Session

The development process involved experimenting with repository ingestion, source-code indexing, model integration, API communication, and deployment.

The goal was to turn an initial idea into a working application that developers could interact with.

[Add your DEV Agent Session link here if your challenge submission provides one.]

The Spirit of It

Software is more than a collection of files.

Every repository represents decisions, experiments, ideas, and hours of work by people who wanted to build something.

Sometimes those people move on.

Sometimes projects become outdated.

Sometimes documentation disappears, and eventually nobody remembers how the system works.

But the code remains.

With Repo Séance, I wanted to explore how open-source AI could help developers recover the knowledge embedded in those forgotten projects.

The interesting part is not simply asking an AI to generate code.

It is asking AI to help us understand code that already exists.

Because even when developers leave, their code deserves to be understood.

What's Next?

Repo Séance is an evolving project, and there is plenty of room to improve it.

Some of the next steps I would like to explore include:

• Semantic search and vector-based retrieval for better code understanding.
• Deeper cross-language source-code analysis.
• More accurate dependency and vulnerability analysis.
• Architecture visualization and module dependency graphs.
• Improved function-level and execution-flow understanding.
• Automated test-generation suggestions.
• Controlled code-modernization workflows.
• Support for larger repositories and more programming languages.

These improvements would move Repo Séance closer to becoming a comprehensive software archaeology and maintenance assistant.

Final Thoughts

Building Repo Séance was an opportunity to explore a practical application of open-weight AI in software engineering.

The project started with a simple question: can we make forgotten software easier to understand?

The result is an application that brings repository ingestion, source exploration, contextual question answering, and report generation together in one place.

There is still much to improve, but the foundation is there.

The past left code. We bring it back to life. 👻