Merge branch 'main' into bug/docker-compose--links-deprecated-#107

Author: Ashishkjain-ai

.vscode/launch.json

@@ -21,7 +21,7 @@
             "program": "${workspaceFolder}/tools/publisher/main.go",
             "args": [
                 "-registry-url=http://localhost:8080",
-                "-mcp-file=${workspaceFolder}/tools/publisher/mcp.json",
+                "-mcp-file=${workspaceFolder}/tools/publisher/server.json",
             ],
         }
     ]

README.md

@@ -289,6 +289,7 @@ The service can be configured using environment variables:
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `MCP_REGISTRY_APP_VERSION`           | Application version | `dev` |
+| `MCP_REGISTRY_DATABASE_TYPE`         | Database type | `mongodb` |
 | `MCP_REGISTRY_COLLECTION_NAME`       | MongoDB collection name | `servers_v2` |
 | `MCP_REGISTRY_DATABASE_NAME`         | MongoDB database name | `mcp-registry` |
 | `MCP_REGISTRY_DATABASE_URL`          | MongoDB connection string | `mongodb://localhost:27017` |

cmd/registry/main.go

@@ -15,6 +15,7 @@ import (
 	"github.com/modelcontextprotocol/registry/internal/auth"
 	"github.com/modelcontextprotocol/registry/internal/config"
 	"github.com/modelcontextprotocol/registry/internal/database"
+	"github.com/modelcontextprotocol/registry/internal/model"
 	"github.com/modelcontextprotocol/registry/internal/service"
 )
 
@@ -33,44 +34,62 @@ 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
-
-	// 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()
+	switch cfg.DatabaseType {
+	case config.DatabaseTypeMemory:
+		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
+		db, err = database.NewMongoDB(ctx, cfg.DatabaseURL, cfg.DatabaseName, cfg.CollectionName)
+		if err != nil {
+			log.Printf("Failed to connect to MongoDB: %v", err)
+			return
+		}
 
-	// Connect to MongoDB
-	mongoDB, err := database.NewMongoDB(ctx, cfg.DatabaseURL, cfg.DatabaseName, cfg.CollectionName)
-	if err != nil {
-		log.Printf("Failed to connect to MongoDB: %v", err)
+		// Create registry service with 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 := db.Close(); err != nil {
+				log.Printf("Error closing MongoDB connection: %v", err)
+			} else {
+				log.Println("MongoDB connection closed successfully")
+			}
+		}()
+	default:
+		log.Printf("Invalid database type: %s; supported types: %s, %s", cfg.DatabaseType, config.DatabaseTypeMemory, config.DatabaseTypeMongoDB)
 		return
 	}
 
-	// Create registry service with MongoDB
-	registryService = service.NewRegistryServiceWithDB(mongoDB)
-	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 {
-			log.Printf("Error closing MongoDB connection: %v", err)
-		} else {
-			log.Println("MongoDB connection closed successfully")
-		}
-	}()
-
+	// Import seed data if requested (works for both memory and MongoDB)
 	if cfg.SeedImport {
 		log.Println("Importing data...")
-		if err := database.ImportSeedFile(mongoDB, cfg.SeedFilePath); err != nil {
+		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")
 		}
-		log.Println("Data import completed successfully")
 	}
 
 	// Initialize authentication services

docker-compose.yml

@@ -5,10 +5,10 @@ services:
     depends_on:
       - mongodb
     environment:
-      - MCP_REGISTRY_DATABASE_URL=mongodb://mongodb:27017
-      - MCP_REGISTRY_ENVIRONMENT=test
-      - MCP_REGISTRY_GITHUB_CLIENT_ID
-      - MCP_REGISTRY_GITHUB_CLIENT_SECRET
+      - MCP_REGISTRY_DATABASE_URL=${MCP_REGISTRY_DATABASE_URL:-mongodb://mongodb:27017}
+      - MCP_REGISTRY_ENVIRONMENT=${MCP_REGISTRY_ENVIRONMENT:-test}
+      - MCP_REGISTRY_GITHUB_CLIENT_ID=${MCP_REGISTRY_GITHUB_CLIENT_ID}
+      - MCP_REGISTRY_GITHUB_CLIENT_SECRET=${MCP_REGISTRY_GITHUB_CLIENT_SECRET}
     ports:
       - 8080:8080
     restart: "unless-stopped"

docs/openapi.yaml

@@ -108,7 +108,6 @@ components:
         - id
         - name
         - description
-        - repository
         - version_detail
       properties:
         id:

internal/config/config.go

@@ -4,18 +4,26 @@ import (
 	env "github.com/caarlos0/env/v11"
 )
 
+type DatabaseType string
+
+const (
+	DatabaseTypeMongoDB DatabaseType = "mongodb"
+	DatabaseTypeMemory  DatabaseType = "memory"
+)
+
 // Config holds the application configuration
 type Config struct {
-	ServerAddress      string `env:"SERVER_ADDRESS" envDefault:":8080"`
-	DatabaseURL        string `env:"DATABASE_URL" envDefault:"mongodb://localhost:27017"`
-	DatabaseName       string `env:"DATABASE_NAME" envDefault:"mcp-registry"`
-	CollectionName     string `env:"COLLECTION_NAME" envDefault:"servers_v2"`
-	LogLevel           string `env:"LOG_LEVEL" envDefault:"info"`
-	SeedFilePath       string `env:"SEED_FILE_PATH" envDefault:"data/seed.json"`
-	SeedImport         bool   `env:"SEED_IMPORT" envDefault:"true"`
-	Version            string `env:"VERSION" envDefault:"dev"`
-	GithubClientID     string `env:"GITHUB_CLIENT_ID" envDefault:""`
-	GithubClientSecret string `env:"GITHUB_CLIENT_SECRET" envDefault:""`
+	ServerAddress      string       `env:"SERVER_ADDRESS" envDefault:":8080"`
+	DatabaseType       DatabaseType `env:"DATABASE_TYPE" envDefault:"mongodb"`
+	DatabaseURL        string       `env:"DATABASE_URL" envDefault:"mongodb://localhost:27017"`
+	DatabaseName       string       `env:"DATABASE_NAME" envDefault:"mcp-registry"`
+	CollectionName     string       `env:"COLLECTION_NAME" envDefault:"servers_v2"`
+	LogLevel           string       `env:"LOG_LEVEL" envDefault:"info"`
+	SeedFilePath       string       `env:"SEED_FILE_PATH" envDefault:"data/seed.json"`
+	SeedImport         bool         `env:"SEED_IMPORT" envDefault:"true"`
+	Version            string       `env:"VERSION" envDefault:"dev"`
+	GithubClientID     string       `env:"GITHUB_CLIENT_ID" envDefault:""`
+	GithubClientSecret string       `env:"GITHUB_CLIENT_SECRET" envDefault:""`
 }
 
 // NewConfig creates a new configuration with default values

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 {