feat(database): support SeedFile import for memory database (#128)

<!-- Provide a brief summary of your changes -->
Add SeedFile import support for memory database to ensure consistent
seed data loading across both MongoDB and memory modes.

## Motivation and Context
<!-- Why is this change needed? What problem does it solve? -->
Previously, SeedFile import was only available when using MongoDB. After
memory database support was added, it lacked this feature, leading to
inconsistent behavior and missing seed data during development or
testing.
This PR solves the problem by enabling the application to load SeedFile
data even when running with a memory database, ensuring consistency and
improving the developer/testing experience.

## How Has This Been Tested?
<!-- Have you tested this in a real application? Which scenarios were
tested? -->


```bash
$ export MCP_REGISTRY_DATABASE_TYPE="memory"
$ ./scripts/test_endpoints.sh
==================================================
MCP Registry Endpoint Test Script
==================================================
This script expects the MCP Registry server to be running locally.
Please ensure the server is started using one of the following methods:
  • Docker Compose: docker compose up
  • Direct execution: go run cmd/registry/main.go
  • Built binary: ./build/registry
==================================================

Testing health endpoint: http://localhost:8080/v0/health
Status Code: 200
Response:
{
  "status": "ok",
  "github_client_id": ""
}
Health check successful
-------------------------------------
Testing servers endpoint: http://localhost:8080/v0/servers
Status Code: 200
Response Summary:
Total registries: 30
servers Names:
io.github.appcypher/awesome-mcp-servers
io.github.kenjihikmatullah/productboard-mcp
io.github.kyrietangsheng/mcp-server-nationalparks
io.github.gongrzhe/redis-mcp-server
io.github.zubeidhendricks/youtube-mcp-server
io.github.zzaebok/mcp-wikidata
io.github.ihor-sokoliuk/mcp-searxng
io.github.sv/mcp-paradex-py
io.github.felores/airtable-mcp
io.github.eqtylab/mcp-guardian
io.github.co-browser/attestable-mcp-server
io.github.ubie-oss/mcp-vertexai-search
io.github.kukapay/crypto-indicators-mcp
io.github.pinecone-io/assistant-mcp
io.github.metricool/mcp-metricool
io.github.r-huijts/strava-mcp
io.github.googleapis/genai-toolbox
io.github.wilsonchenghy/shadertoy-mcp
io.github.klavis-ai/klavis
io.github.fireproof-storage/mcp-database-server
io.github.xxxbrian/mcp-rquest
io.github.geropl/linear-mcp-go
io.github.amornpan/py-mcp-mssql
io.github.chaindead/telegram-mcp
io.github.bazinga012/mcp_code_executor
io.github.lharries/whatsapp-mcp
io.github.mektigboy/server-hyperliquid
io.github.omar-v2/mcp-ical
io.github.open-strategy-partners/osp_marketing_tools
io.github.smn2gnt/mcp-salesforce

Pagination Metadata:
{
  "next_cursor": "0e45cb5a-5b45-47f3-8b5e-12bdf88d176a",
  "count": 30
}

servers Details:
{
  "servers": [
    {
      "id": "0007544a-3948-4934-866b-b4a96fe53b55",
      "name": "io.github.appcypher/awesome-mcp-servers",
      "description": "Awesome MCP Servers - A curated list of Model Context Protocol servers",
      "repository": {
        "url": "https://github.com/appcypher/awesome-mcp-servers",
        "source": "github",
        "id": "895801050"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:16:40Z",
        "is_latest": true
      }
    },
    {
      "id": "00613acb-73e2-4f93-8b96-296df17316c8",
      "name": "io.github.kenjihikmatullah/productboard-mcp",
      "description": "Integrate the Productboard API into agentic workflows via MCP",
      "repository": {
        "url": "https://github.com/kenjihikmatullah/productboard-mcp",
        "source": "github",
        "id": "939104710"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:12:44Z",
        "is_latest": true
      }
    },
    {
      "id": "010904ec-6e39-4bdc-878a-75a6e79d0500",
      "name": "io.github.kyrietangsheng/mcp-server-nationalparks",
      "description": "",
      "repository": {
        "url": "https://github.com/KyrieTangSheng/mcp-server-nationalparks",
        "source": "github",
        "id": "951713109"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:11:05Z",
        "is_latest": true
      }
    },
    {
      "id": "01129bff-3d65-4e3d-8e82-6f2f269f818c",
      "name": "io.github.gongrzhe/redis-mcp-server",
      "description": "A Redis MCP server (pushed to https://github.com/modelcontextprotocol/servers/tree/main/src/redis) implementation for interacting with Redis databases. This server enables LLMs to interact with Redis key-value stores through a set of standardized tools.",
      "repository": {
        "url": "https://github.com/GongRzhe/REDIS-MCP-Server",
        "source": "github",
        "id": "907849235"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:21Z",
        "is_latest": true
      }
    },
    {
      "id": "0278fd92-a009-4a47-a6df-5f77db37e6ab",
      "name": "io.github.zubeidhendricks/youtube-mcp-server",
      "description": "MCP Server for YouTube API, enabling video management, Shorts creation, and advanced analytics",
      "repository": {
        "url": "https://github.com/ZubeidHendricks/youtube-mcp-server",
        "source": "github",
        "id": "909607678"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:16:14Z",
        "is_latest": true
      }
    },
    {
      "id": "02b79b89-cce8-4401-aa1f-255b01587266",
      "name": "io.github.zzaebok/mcp-wikidata",
      "description": "A server implementation for Wikidata API using the Model Context Protocol (MCP).",
      "repository": {
        "url": "https://github.com/zzaebok/mcp-wikidata",
        "source": "github",
        "id": "959274715"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:15:49Z",
        "is_latest": true
      }
    },
    {
      "id": "02cdb980-1dcd-4345-a8d1-d3f3f522d04b",
      "name": "io.github.ihor-sokoliuk/mcp-searxng",
      "description": "MCP Server for SearXNG",
      "repository": {
        "url": "https://github.com/ihor-sokoliuk/mcp-searxng",
        "source": "github",
        "id": "907172461"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:48Z",
        "is_latest": true
      }
    },
    {
      "id": "038a3024-c319-4a07-bd7f-9cf699cfebf1",
      "name": "io.github.sv/mcp-paradex-py",
      "description": "Connect AI agents to the Paradex trading platform. Retrieve market data, manage accounts, and execute trades seamlessly. Enhance your trading experience with automated tools and real-time insights.",
      "repository": {
        "url": "https://github.com/sv/mcp-paradex-py",
        "source": "github",
        "id": "944258239"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:12:24Z",
        "is_latest": true
      }
    },
    {
      "id": "04216a87-0760-4f25-b809-42ffbfbb8962",
      "name": "io.github.felores/airtable-mcp",
      "description": "Search, create and update Airtable bases, tables, fields, and records using Claude Desktop and MCP (Model Context Protocol) clients",
      "repository": {
        "url": "https://github.com/felores/airtable-mcp",
        "source": "github",
        "id": "904238387"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:02:48Z",
        "is_latest": true
      }
    },
    {
      "id": "04b4489b-db48-4aaa-98f6-036bcf5fd483",
      "name": "io.github.eqtylab/mcp-guardian",
      "description": "Manage / Proxy / Secure your MCP Servers",
      "repository": {
        "url": "https://github.com/eqtylab/mcp-guardian",
        "source": "github",
        "id": "926222936"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:16:58Z",
        "is_latest": true
      }
    },
    {
      "id": "05ca6ccc-d6e1-47ab-ab8d-25949db9ada7",
      "name": "io.github.co-browser/attestable-mcp-server",
      "description": "Verify that any MCP server is running the intended and untampered code via hardware attestation.",
      "repository": {
        "url": "https://github.com/co-browser/attestable-mcp-server",
        "source": "github",
        "id": "955641588"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:03:19Z",
        "is_latest": true
      }
    },
    {
      "id": "07ccf835-680a-42b4-bf0b-db28367519ee",
      "name": "io.github.ubie-oss/mcp-vertexai-search",
      "description": "A MCP server for Vertex AI Search",
      "repository": {
        "url": "https://github.com/ubie-oss/mcp-vertexai-search",
        "source": "github",
        "id": "934580342"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:07:44Z",
        "is_latest": true
      }
    },
    {
      "id": "0852caec-a861-4f9c-9e94-a7c8b67a1641",
      "name": "io.github.kukapay/crypto-indicators-mcp",
      "description": "An MCP server providing a range of cryptocurrency technical analysis indicators and strategies.",
      "repository": {
        "url": "https://github.com/kukapay/crypto-indicators-mcp",
        "source": "github",
        "id": "953321792"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:05:01Z",
        "is_latest": true
      }
    },
    {
      "id": "08668c6a-c2f6-47b0-a4e0-75a8ee9bcf10",
      "name": "io.github.pinecone-io/assistant-mcp",
      "description": "Pinecone Assistant MCP server",
      "repository": {
        "url": "https://github.com/pinecone-io/assistant-mcp",
        "source": "github",
        "id": "940446625"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:01:06Z",
        "is_latest": true
      }
    },
    {
      "id": "091ef217-8e6d-4e06-8cb9-bc5ffe5467b1",
      "name": "io.github.metricool/mcp-metricool",
      "description": "This is a Multi-Agent Collaboration Protocol (MCP) server for interacting with the Metricool API. It allows AI agents to access and analyze social media metrics and campaign data from your Metricool account.",
      "repository": {
        "url": "https://github.com/metricool/mcp-metricool",
        "source": "github",
        "id": "967888435"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:10:11Z",
        "is_latest": true
      }
    },
    {
      "id": "09a2ecf8-1774-490e-8542-2b25a6445a58",
      "name": "io.github.r-huijts/strava-mcp",
      "description": "A Model Context Protocol (MCP) server that connects to Strava API, providing tools to access Strava data through LLMs",
      "repository": {
        "url": "https://github.com/r-huijts/strava-mcp",
        "source": "github",
        "id": "961429605"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:14:17Z",
        "is_latest": true
      }
    },
    {
      "id": "09f19715-3a0c-4900-932b-1ff0035aff11",
      "name": "io.github.googleapis/genai-toolbox",
      "description": "MCP Toolbox for Databases is an open source MCP server for databases.",
      "repository": {
        "url": "https://github.com/googleapis/genai-toolbox",
        "source": "github",
        "id": "812044182"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:00:18Z",
        "is_latest": true
      }
    },
    {
      "id": "0b245c5f-ba2b-4e8d-b9db-26681b0fa2e3",
      "name": "io.github.wilsonchenghy/shadertoy-mcp",
      "description": "",
      "repository": {
        "url": "https://github.com/wilsonchenghy/ShaderToy-MCP",
        "source": "github",
        "id": "958998300"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:14:23Z",
        "is_latest": true
      }
    },
    {
      "id": "0bc33e11-876e-4b0f-9c72-75c126d89978",
      "name": "io.github.klavis-ai/klavis",
      "description": "Klavis AI (YC X25):  Open Source MCP integration for AI applications",
      "repository": {
        "url": "https://github.com/Klavis-AI/klavis",
        "source": "github",
        "id": "965974441"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T18:59:59Z",
        "is_latest": true
      }
    },
    {
      "id": "0bee6074-d16a-4482-a315-5b8f0f1abcf1",
      "name": "io.github.fireproof-storage/mcp-database-server",
      "description": "Store and load JSON documents from LLM tool use",
      "repository": {
        "url": "https://github.com/fireproof-storage/mcp-database-server",
        "source": "github",
        "id": "904432283"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T18:58:57Z",
        "is_latest": true
      }
    },
    {
      "id": "0c43f128-7589-4ce6-9382-5399ba24bebd",
      "name": "io.github.xxxbrian/mcp-rquest",
      "description": "A MCP server providing realistic browser-like HTTP request capabilities with accurate TLS/JA3/JA4 fingerprints for bypassing anti-bot measures. It also supports converting PDF and HTML documents to Markdown for easier processing by LLMs.",
      "repository": {
        "url": "https://github.com/xxxbrian/mcp-rquest",
        "source": "github",
        "id": "950863558"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:30Z",
        "is_latest": true
      }
    },
    {
      "id": "0c8e4aae-53ed-4acf-87d9-19d44ac4afd1",
      "name": "io.github.geropl/linear-mcp-go",
      "description": "linear MCP server based on mcp-go",
      "repository": {
        "url": "https://github.com/geropl/linear-mcp-go",
        "source": "github",
        "id": "940084523"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:09:19Z",
        "is_latest": true
      }
    },
    {
      "id": "0c9a70a7-7523-42b7-a951-b4c4b8077710",
      "name": "io.github.amornpan/py-mcp-mssql",
      "description": "py-mcp-mssql",
      "repository": {
        "url": "https://github.com/amornpan/py-mcp-mssql",
        "source": "github",
        "id": "922607489"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:10:17Z",
        "is_latest": true
      }
    },
    {
      "id": "0cd13ce0-2f67-414a-afb1-4e11dd3e4cba",
      "name": "io.github.chaindead/telegram-mcp",
      "description": "Telegram MCP for managing dialogs, messages, drafts, read statuses, and more.",
      "repository": {
        "url": "https://github.com/chaindead/telegram-mcp",
        "source": "github",
        "id": "958652024"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:14:34Z",
        "is_latest": true
      }
    },
    {
      "id": "0cdfed38-6495-42a3-a837-3788f35aadd3",
      "name": "io.github.bazinga012/mcp_code_executor",
      "description": "The MCP Code Executor is an MCP server that allows LLMs to execute Python code within a specified Conda environment.",
      "repository": {
        "url": "https://github.com/bazinga012/mcp_code_executor",
        "source": "github",
        "id": "928420039"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:04:37Z",
        "is_latest": true
      }
    },
    {
      "id": "0d2cbcc1-4b34-4b2b-af66-595d8fb5e78a",
      "name": "io.github.lharries/whatsapp-mcp",
      "description": "WhatsApp MCP server",
      "repository": {
        "url": "https://github.com/lharries/whatsapp-mcp",
        "source": "github",
        "id": "957053334"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:15:45Z",
        "is_latest": true
      }
    },
    {
      "id": "0d57edf7-3fbb-42b4-aa9e-b255e7d6f8fa",
      "name": "io.github.mektigboy/server-hyperliquid",
      "description": "MCP Hyperliquid (https://app.hyperliquid.xyz) server",
      "repository": {
        "url": "https://github.com/mektigboy/server-hyperliquid",
        "source": "github",
        "id": "943734921"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:08:12Z",
        "is_latest": true
      }
    },
    {
      "id": "0d7bc864-fdf3-4afd-8b44-48468b12d550",
      "name": "io.github.omar-v2/mcp-ical",
      "description": "A Model Context Protocol Server that allows you to interact with your MacOS Calendar through natural language.",
      "repository": {
        "url": "https://github.com/Omar-V2/mcp-ical",
        "source": "github",
        "id": "930007673"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:03:05Z",
        "is_latest": true
      }
    },
    {
      "id": "0d8b287c-6023-4809-a5ba-963c5612efa2",
      "name": "io.github.open-strategy-partners/osp_marketing_tools",
      "description": "A Model Context Protocol (MCP) server that empowers LLMs to use some of Open Srategy Partners' core writing and product marketing techniques.",
      "repository": {
        "url": "https://github.com/open-strategy-partners/osp_marketing_tools",
        "source": "github",
        "id": "917730483"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:12:14Z",
        "is_latest": true
      }
    },
    {
      "id": "0e45cb5a-5b45-47f3-8b5e-12bdf88d176a",
      "name": "io.github.smn2gnt/mcp-salesforce",
      "description": "MCP Salesforce connector",
      "repository": {
        "url": "https://github.com/smn2gnt/MCP-Salesforce",
        "source": "github",
        "id": "904538810"
      },
      "version_detail": {
        "version": "0.0.1-seed",
        "release_date": "2025-05-16T19:13:41Z",
        "is_latest": true
      }
    }
  ],
  "metadata": {
    "next_cursor": "0e45cb5a-5b45-47f3-8b5e-12bdf88d176a",
    "count": 30
  }
}
servers request successful
-------------------------------------
Testing ping endpoint: http://localhost:8080/v0/ping
Status Code: 200
Response:
{
  "status": "ok",
  "version": "dev"
}
Ping successful
-------------------------------------
All tests passed successfully!
```

## Breaking Changes
<!-- Will users need to update their code or configurations? -->
No

## Types of changes
<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [x] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update

## Checklist
<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->
- [x] I have read the [MCP
Documentation](https://modelcontextprotocol.io)
- [x] My code follows the repository's style guidelines
- [x] New and existing tests pass locally
- [x] I have added appropriate error handling
- [ ] I have added or updated documentation as needed

## Additional context
<!-- Add any other context, implementation notes, or design decisions
-->
Close #127

Author: chenmingyong0423

cmd/registry/main.go

@@ -34,56 +34,64 @@ func main() {
 
 	log.Printf("Starting MCP Registry Application v%s (commit: %s)", Version, GitCommit)
 
+	var (
+		registryService service.RegistryService
+		db              database.Database
+		err             error
+	)
+
 	// Initialize configuration
 	cfg := config.NewConfig()
 
 	// Initialize services based on environment
-	var registryService service.RegistryService
-
 	switch cfg.DatabaseType {
 	case config.DatabaseTypeMemory:
-		memoryDB := database.NewMemoryDB(map[string]*model.Server{})
-		registryService = service.NewRegistryServiceWithDB(memoryDB)
+		db = database.NewMemoryDB(map[string]*model.Server{})
+		registryService = service.NewRegistryServiceWithDB(db)
 	case config.DatabaseTypeMongoDB:
 		// Use MongoDB for real registry service in production/other environments
 		// Create a context with timeout for MongoDB connection
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
 		// Connect to MongoDB
-		mongoDB, err := database.NewMongoDB(ctx, cfg.DatabaseURL, cfg.DatabaseName, cfg.CollectionName)
+		db, err = database.NewMongoDB(ctx, cfg.DatabaseURL, cfg.DatabaseName, cfg.CollectionName)
 		if err != nil {
 			log.Printf("Failed to connect to MongoDB: %v", err)
 			return
 		}
 
 		// Create registry service with MongoDB
-		registryService = service.NewRegistryServiceWithDB(mongoDB)
+		registryService = service.NewRegistryServiceWithDB(db)
 		log.Printf("MongoDB database name: %s", cfg.DatabaseName)
 		log.Printf("MongoDB collection name: %s", cfg.CollectionName)
 
 		// Store the MongoDB instance for later cleanup
 		defer func() {
-			if err := mongoDB.Close(); err != nil {
+			if err := db.Close(); err != nil {
 				log.Printf("Error closing MongoDB connection: %v", err)
 			} else {
 				log.Println("MongoDB connection closed successfully")
 			}
 		}()
-
-		if cfg.SeedImport {
-			log.Println("Importing data...")
-			if err := database.ImportSeedFile(mongoDB, cfg.SeedFilePath); err != nil {
-				log.Printf("Failed to import seed file: %v", err)
-			} else {
-				log.Println("Data import completed successfully")
-			}
-		}
 	default:
 		log.Printf("Invalid database type: %s; supported types: %s, %s", cfg.DatabaseType, config.DatabaseTypeMemory, config.DatabaseTypeMongoDB)
 		return
 	}
 
+	// Import seed data if requested (works for both memory and MongoDB)
+	if cfg.SeedImport {
+		log.Println("Importing data...")
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+
+		if err := db.ImportSeed(ctx, cfg.SeedFilePath); err != nil {
+			log.Printf("Failed to import seed file: %v", err)
+		} else {
+			log.Println("Data import completed successfully")
+		}
+	}
+
 	// Initialize authentication services
 	authService := auth.NewAuthService(cfg)
 

internal/database/database.go

@@ -24,6 +24,8 @@ type Database interface {
 	GetByID(ctx context.Context, id string) (*model.ServerDetail, error)
 	// Publish adds a new ServerDetail to the database
 	Publish(ctx context.Context, serverDetail *model.ServerDetail) error
+	// ImportSeed imports initial data from a seed file
+	ImportSeed(ctx context.Context, seedFilePath string) error
 	// Close closes the database connection
 	Close() error
 }

internal/database/import.go

@@ -1,50 +1,28 @@
 package database
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"log"
 	"os"
 	"path/filepath"
-	"time"
 
 	"github.com/modelcontextprotocol/registry/internal/model"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
-// ImportSeedFile populates the MongoDB database with initial data from a seed file.
-func ImportSeedFile(mongo *MongoDB, seedFilePath string) error {
+// ReadSeedFile reads and parses the seed.json file - exported for use by all database implementations
+func ReadSeedFile(path string) ([]model.ServerDetail, error) {
+	log.Printf("Reading seed file from %s", path)
+
 	// Set default seed file path if not provided
-	if seedFilePath == "" {
+	if path == "" {
 		// Try to find the seed.json in the data directory
-		seedFilePath = filepath.Join("data", "seed.json")
-		if _, err := os.Stat(seedFilePath); os.IsNotExist(err) {
-			return fmt.Errorf("seed file not found at %s", seedFilePath)
+		path = filepath.Join("data", "seed.json")
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return nil, fmt.Errorf("seed file not found at %s", path)
 		}
 	}
 
-	// Create a context with timeout for the database operations
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
-	defer cancel()
-
-	// Read the seed file
-	seedData, err := readSeedFile(seedFilePath)
-	if err != nil {
-		return fmt.Errorf("failed to read seed file: %w", err)
-	}
-
-	collection := mongo.collection
-	importData(ctx, collection, seedData)
-	return nil
-}
-
-// readSeedFile reads and parses the seed.json file
-func readSeedFile(path string) ([]model.ServerDetail, error) {
-	log.Printf("Reading seed file from %s", path)
-
 	// Read the file content
 	fileContent, err := os.ReadFile(path)
 	if err != nil {
@@ -64,44 +42,3 @@ func readSeedFile(path string) ([]model.ServerDetail, error) {
 	log.Printf("Found %d server entries in seed file", len(servers))
 	return servers, nil
 }
-
-// importData imports the seed data into MongoDB
-func importData(ctx context.Context, collection *mongo.Collection, servers []model.ServerDetail) {
-	log.Printf("Importing %d servers into collection %s", len(servers), collection.Name())
-
-	for i, server := range servers {
-		if server.ID == "" || server.Name == "" {
-			log.Printf("Skipping server %d: ID or Name is empty", i+1)
-			continue
-		}
-		// Create filter based on server ID
-		filter := bson.M{"id": server.ID}
-
-		if server.VersionDetail.Version == "" {
-			server.VersionDetail.Version = "0.0.1-seed"
-			server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
-			server.VersionDetail.IsLatest = true
-		}
-		// Create update document
-		update := bson.M{"$set": server}
-
-		// Use upsert to create if not exists or update if exists
-		opts := options.Update().SetUpsert(true)
-		result, err := collection.UpdateOne(ctx, filter, update, opts)
-		if err != nil {
-			log.Printf("Error importing server %s: %v", server.ID, err)
-			continue
-		}
-
-		switch {
-		case result.UpsertedCount > 0:
-			log.Printf("[%d/%d] Created server: %s", i+1, len(servers), server.Name)
-		case result.ModifiedCount > 0:
-			log.Printf("[%d/%d] Updated server: %s", i+1, len(servers), server.Name)
-		default:
-			log.Printf("[%d/%d] Server already up to date: %s", i+1, len(servers), server.Name)
-		}
-	}
-
-	log.Println("Import completed successfully")
-}

internal/database/memory.go

@@ -2,6 +2,8 @@ package database
 
 import (
 	"context"
+	"fmt"
+	"log"
 	"sort"
 	"strconv"
 	"strings"
@@ -249,6 +251,47 @@ func (db *MemoryDB) Publish(ctx context.Context, serverDetail *model.ServerDetai
 	return nil
 }
 
+// ImportSeed imports initial data from a seed file into memory database
+func (db *MemoryDB) ImportSeed(ctx context.Context, seedFilePath string) error {
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+
+	// Read the seed file
+	seedData, err := ReadSeedFile(seedFilePath)
+	if err != nil {
+		return fmt.Errorf("failed to read seed file: %w", err)
+	}
+
+	log.Printf("Importing %d servers into memory database", len(seedData))
+
+	db.mu.Lock()
+	defer db.mu.Unlock()
+
+	for i, server := range seedData {
+		if server.ID == "" || server.Name == "" {
+			log.Printf("Skipping server %d: ID or Name is empty", i+1)
+			continue
+		}
+
+		// Set default version information if missing
+		if server.VersionDetail.Version == "" {
+			server.VersionDetail.Version = "0.0.1-seed"
+			server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
+			server.VersionDetail.IsLatest = true
+		}
+
+		// Store a copy of the server detail
+		serverDetailCopy := server
+		db.entries[server.ID] = &serverDetailCopy
+
+		log.Printf("[%d/%d] Imported server: %s", i+1, len(seedData), server.Name)
+	}
+
+	log.Println("Memory database import completed successfully")
+	return nil
+}
+
 // Close closes the database connection
 // For an in-memory database, this is a no-op
 func (db *MemoryDB) Close() error {

internal/database/mongo.go

@@ -232,6 +232,58 @@ func (db *MongoDB) Publish(ctx context.Context, serverDetail *model.ServerDetail
 	return nil
 }
 
+// ImportSeed imports initial data from a seed file into MongoDB
+func (db *MongoDB) ImportSeed(ctx context.Context, seedFilePath string) error {
+	// Read the seed file
+	servers, err := ReadSeedFile(seedFilePath)
+	if err != nil {
+		return fmt.Errorf("failed to read seed file: %w", err)
+	}
+
+	collection := db.collection
+
+	log.Printf("Importing %d servers into collection %s", len(servers), collection.Name())
+
+	for i, server := range servers {
+		if server.ID == "" || server.Name == "" {
+			log.Printf("Skipping server %d: ID or Name is empty", i+1)
+			continue
+		}
+
+		if server.VersionDetail.Version == "" {
+			server.VersionDetail.Version = "0.0.1-seed"
+			server.VersionDetail.ReleaseDate = time.Now().Format(time.RFC3339)
+			server.VersionDetail.IsLatest = true
+		}
+
+		// Create filter based on server ID
+		filter := bson.M{"id": server.ID}
+
+		// Create update document
+		update := bson.M{"$set": server}
+
+		// Use upsert to create if not exists or update if exists
+		opts := options.Update().SetUpsert(true)
+		result, err := collection.UpdateOne(ctx, filter, update, opts)
+		if err != nil {
+			log.Printf("Error importing server %s: %v", server.ID, err)
+			continue
+		}
+
+		switch {
+		case result.UpsertedCount > 0:
+			log.Printf("[%d/%d] Created server: %s", i+1, len(servers), server.Name)
+		case result.ModifiedCount > 0:
+			log.Printf("[%d/%d] Updated server: %s", i+1, len(servers), server.Name)
+		default:
+			log.Printf("[%d/%d] Server already up to date: %s", i+1, len(servers), server.Name)
+		}
+	}
+
+	log.Println("MongoDB database import completed successfully")
+	return nil
+}
+
 // Close closes the database connection
 func (db *MongoDB) Close() error {
 	return db.client.Disconnect(context.Background())