Sqlite Literature Management Fastmcp MCP Server

🚀 Unified Source Management System

A flexible system for managing various types of sources (papers, books, webpages, etc.) and integrating them with a knowledge graph.

🚀 Quick Start

This system integrates with the MCP Memory Server for persistent knowledge graph storage.

1. Create a new SQLite database using our schema:

# Create a new database
sqlite3 sources.db < create_sources_db.sql

2. Install the source management server:

# Install for Claude Desktop, specifying the database path
fastmcp install source-manager-server.py --name "Source Manager" -e SQLITE_DB_PATH=/path/to/sources.db

✨ Features

Core Features

• Implement unified source identification using an internal UUID system.
• Support multiple source types (papers, webpages, books, videos, blogs).
• Each source supports multiple identifiers (arxiv, DOI, Semantic Scholar, ISBN, URL).
• Structured note-taking feature with titles and content.
• Track status (unread, reading, completed, archived).

Entity Integration

• Link sources to knowledge graph entities.
• Track relationships between sources and entities.
• Support flexible relationship types (discusses, introduces, extends, evaluates, etc.).
• Integrate with the memory graph.

📦 Installation

This system integrates with the MCP Memory Server for persistent knowledge graph storage.

💻 Usage Examples

Basic Usage

1. Managing Sources

Add a paper with multiple identifiers:

add_source(
    title="Attention Is All You Need",
    type="paper",
    identifier_type="arxiv",
    identifier_value="1706.03762",
    initial_note={
        "title": "Initial Thoughts",
        "content": "Pioneering paper introducing the transformer architecture..."
    }
)

# Add another identifier for the same paper
add_identifier(
    title="Attention Is All You Need",
    type="paper",
    current_identifier_type="arxiv",
    current_identifier_value="1706.03762",
    new_identifier_type="url",
    new_identifier_value="https://arxiv.org/abs/1706.03762"
)

Add a webpage:

add_source(
    title="How to Use Deep Learning for Natural Language Processing",
    type="webpage",
    identifier_type="url",
    identifier_value="https://www.tensorflow.org/text",
    initial_note={
        "title": "Quick Start Guide",
        "content": "Introduces the basics of text processing using TensorFlow..."
    }
)

2. Managing Status

Mark a source as read:

update_status(source_id, 'completed')

Get all unread papers:

get_sources_by_status('unread', 'paper')

3. Managing Entity Relationships

Link a paper to an entity:

link_entity(
    source_id,
    entity_name="transformer_architecture",
    relation_type="introduces"
)

Get all related entities:

get_linked_entities(source_id)

📚 Documentation

Best Practices

1. Data Organization:
   • Classify using clear titles and types.
   • Regularly clean up outdated or irrelevant sources.
2. Note Management:
   • Create structured notes for each important discovery or insight.
   • Use appropriate tags and classifications to improve retrieval efficiency.
3. Status Tracking:
   • Update source status in a timely manner to maintain data accuracy.
   • Regularly review completed tasks for summarization and archiving.

Contribution Guidelines

1. Steps:
   • Fork the repository.
   • Create a feature branch.
   • Add tests for new features.
   • Submit a pull request.
2. Code Standards:
   • Follow the PEP8 coding standard.
   • Provide detailed documentation and comments.
3. Testing Requirements:
   • Ensure new features pass unit tests.
   • Update existing test cases to cover new features.

🔧 Technical Details

1. Data Model:
   • The sources table stores basic source information.
   • The source_notes table records notes related to sources.
   • The source_entity_links table tracks relationships between sources and other entities.
2. Query Optimization:
   • Use indexes to speed up common queries, such as filtering by type and status.
   • Regularly analyze query performance and optimize the database structure.
3. Scalability:
   • Support multiple identifier types for easy integration of different data sources.
   • Flexible relationship type design to meet various knowledge representation needs.

📄 Database Schema

Core Tables

-- Source table
CREATE TABLE sources (
    id UUID PRIMARY KEY,
    title TEXT NOT NULL,
    type TEXT CHECK(type IN ('paper', 'webpage', 'book', 'video', 'blog')) NOT NULL,
    identifiers JSONB NOT NULL,
    status TEXT CHECK(status IN ('unread', 'reading', 'completed', 'archived')) DEFAULT 'unread'
);

-- Source notes
CREATE TABLE source_notes (
    source_id UUID REFERENCES sources(id),
    note_title TEXT NOT NULL,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (source_id, note_title)
);

-- Entity links
CREATE TABLE source_entity_links (
    source_id UUID REFERENCES sources(id),
    entity_name TEXT,
    relation_type TEXT CHECK(relation_type IN ('discusses', 'introduces', 'extends', 'evaluates', 'applies', 'critiques')),
    notes TEXT,
    PRIMARY KEY (source_id, entity_name)
);