What Database Does the VoiceStudio Backend Use? SQLite Implementation Guide

The VoiceStudio backend uses SQLite as its sole persistent data store, implementing WAL journaling and foreign-key enforcement through a custom connection manager in backend/core/db.py.

The VoiceStudio project by debpalash/VoiceStudio relies on a lightweight, serverless database solution for managing voice profiles, generation history, and application state. Understanding what database the VoiceStudio backend uses is essential for developers contributing to the codebase or deploying the application locally. The backend implements SQLite with specific performance and integrity optimizations configured at the connection level.

SQLite as the Primary Data Store

SQLite serves as the embedded database engine for all persistent storage needs in VoiceStudio. Unlike client-server databases such as PostgreSQL or MySQL, SQLite operates as an in-process library that reads and writes directly to disk files. This design choice eliminates separate server configuration while maintaining ACID compliance for voice profile data, job tracking metadata, and user settings.

The database file path is determined by the core.config.DB_PATH configuration variable, allowing flexible deployment across development and production environments without modifying connection logic.

Core Database Implementation in backend/core/db.py

The database layer is centralized in backend/core/db.py, which exposes two primary interfaces for database access: a direct connection factory and a transactional context manager.

Connection Initialization with get_db()

The get_db() function establishes raw SQLite connections with production-ready pragmas enabled. According to the VoiceStudio source code, this function configures the connection with Write-Ahead Logging (WAL) mode for improved concurrency and enables foreign key enforcement to maintain referential integrity across tables.

# Obtain a raw SQLite connection

from backend.core.db import get_db

conn = get_db()
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM voice_profiles")
print("Number of profiles:", cursor.fetchone()[0])
conn.close()

Safe Transaction Handling with db_conn()

For production code, VoiceStudio provides the db_conn() context manager, which guarantees that transactions are properly committed or rolled back and that connections are always closed, even when exceptions occur. This pattern prevents database locks and resource leaks during voice generation operations.

# Use the provided context manager for safe transactions

from backend.core.db import db_conn

with db_conn() as conn:
    conn.execute(
        "INSERT INTO voice_profiles (id, name, created_at) VALUES (?, ?, ?)",
        ("profile-123", "My Voice", 1700000000.0),
    )

# Transaction is committed automatically; connection is closed afterwards.

Alembic Migration Configuration

Schema versioning is handled through Alembic, configured in backend/migrations/env.py to target the same SQLite database used by the application runtime. When no explicit sqlalchemy.url is provided in the environment configuration, the Alembic environment constructs the database URL as sqlite:///<DB_PATH>, ensuring migration scripts execute against the correct file.

This integration allows VoiceStudio to manage schema evolution for tables storing voice profiles, generation history, and application settings through standard Alembic revision files located in backend/migrations/versions/.

Working with the VoiceStudio Database

Developers interacting with the VoiceStudio backend database should use the provided abstractions rather than instantiating raw SQLite connections directly. The db_conn() context manager is the recommended approach for all write operations, while get_db() is available for read-only queries or custom transaction logic.

All persistent data—including voice synthesis jobs, audio generation history, and configuration settings—resides within this single SQLite file, making backup and migration straightforward for self-hosted deployments.

Summary

• SQLite is the exclusive database engine used by the VoiceStudio backend for all persistent storage.
• The backend/core/db.py module provides get_db() for connections and db_conn() for transactional safety.
• Database connections enable WAL journaling and foreign key constraints by default.
• Alembic handles schema migrations via backend/migrations/env.py, targeting the same SQLite file defined by core.config.DB_PATH.

Frequently Asked Questions

What database does the VoiceStudio backend use?

The VoiceStudio backend uses SQLite as its sole database system. All voice profiles, generation history, job tracking data, and application settings are stored in a single SQLite file defined by the DB_PATH configuration variable.

Where is the VoiceStudio database file located?

The database file location is controlled by core.config.DB_PATH, which is typically set to a local path within the project directory. For development environments, this often resolves to a .db file in the backend root or a dedicated data/ directory.

Does VoiceStudio support PostgreSQL or MySQL?

No. According to the source code in backend/core/db.py and backend/migrations/env.py, VoiceStudio is architected specifically for SQLite. The connection logic and Alembic configuration hardcode SQLite-specific pragmas and URL schemes, making migration to other database engines require significant code modification.

How are database migrations handled in VoiceStudio?

VoiceStudio uses Alembic for schema migrations. The migration environment in backend/migrations/env.py automatically constructs a sqlite:/// URL pointing to the configured DB_PATH. Migration scripts stored in backend/migrations/versions/—such as 0001_phase1_settings_table.py—execute DDL operations against this SQLite database to create and modify tables.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}