✨ Add mcp and gpt commands to connect Anyquery to LLMs

Author: julien040

.goreleaser.yaml

@@ -153,7 +153,7 @@ chocolateys:
       Anyquery is a query engine that allows you to query anything over SQL. It's built on top of SQLite.
 
     icon_url: https://anyquery.dev/favicon.png
-    copyright: 2024 Julien CAGNIART
+    copyright: 2025 Julien CAGNIART
     tags: "anyquery sql sqlite mysql query database api"
     package_source_url: https://github.com/julien040/anyquery
     release_notes: "See release notes at https://github.com/julien040/anyquery/releases"
@@ -240,7 +240,7 @@ winget:
     homepage: https://anyquery.dev
     license_url: https://github.com/julien040/anyquery/blob/main/LICENSE.md
     skip_upload: false
-    copyright: 2024 Julien CAGNIART
+    copyright: 2025 Julien CAGNIART
     copyright_url: https://github.com/julien040/anyquery/blob/main/LICENSE.md
     tags:
       - anyquery

.vscode/settings.json

@@ -1,3 +1,6 @@
 {
-    "go.buildTags": "vtable fts5 sqlite_json sqlite_math_functions"
+    "go.buildTags": "vtable fts5 sqlite_json sqlite_math_functions",
+    "yaml.schemas": {
+        "https://spec.openapis.org/oas/3.1/schema/2022-10-07": "file:///Users/julien/Code/anyquery/other/llm/openapi-actions.yaml"
+    }
 }

cmd/llm.go

@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"github.com/julien040/anyquery/controller"
+	"github.com/spf13/cobra"
+)
+
+var gptCmd = &cobra.Command{
+	Use:     "gpt",
+	Aliases: []string{"chat", "chatgpt"},
+	Short:   "Open an HTTP server so that ChatGPT can do function calls",
+	Long: `Open an HTTP server so that ChatGPT can do function calls. By default, it will expose a tunnel to the internet.
+By setting the --host or --port flags, you can disable the tunnel and bind to a specific host and port. In this case, you will need to configure your LLM to connect to this host and port.`,
+
+	RunE: controller.Gpt,
+}
+
+var mcpCmd = &cobra.Command{
+	Use:   "mcp",
+	Short: "Start the Model Context Protocol (MCP) server",
+	Long: `Start the Model Context Protocol (MCP) server. It is used to provide context for LLM that supports it. 
+Pass the --stdio flag to use standard input/output for communication. By default, it will bind locally to localhost:8070 (modify it with the --host, --port and --domain flags).
+You can also expose the tunnel to the internet by using the --tunnel flag (useful when the LLM is on a remote server).
+`,
+	RunE: controller.Mcp,
+}
+
+func init() {
+	// GPT command
+	rootCmd.AddCommand(gptCmd)
+	addFlag_commandModifiesConfiguration(gptCmd)
+	gptCmd.Flags().StringP("database", "d", "", "Database to connect to (a path or :memory:)")
+	gptCmd.Flags().Bool("in-memory", false, "Use an in-memory database")
+	gptCmd.Flags().Bool("readonly", false, "Open the SQLite database in read-only mode")
+	gptCmd.Flags().Bool("read-only", false, "Open the SQLite database in read-only mode")
+	gptCmd.Flags().StringSlice("extension", []string{}, "Load one or more extensions by specifying their path. Separate multiple extensions with a comma.")
+	gptCmd.Flags().String("log-file", "", "Log file")
+	gptCmd.Flags().String("log-level", "info", "Log level (trace, debug, info, warn, error, off)")
+	gptCmd.Flags().String("log-format", "text", "Log format (text, json)")
+	gptCmd.Flags().String("host", "", "Host to bind to. If not empty, the tunnel will be disabled")
+	gptCmd.Flags().Int("port", 0, "Port to bind to. If not empty, the tunnel will be disabled")
+
+	// MCP command
+	rootCmd.AddCommand(mcpCmd)
+	addFlag_commandModifiesConfiguration(mcpCmd)
+	mcpCmd.Flags().String("host", "127.0.0.1", "Host to bind to")
+	mcpCmd.Flags().String("domain", "", "Domain to use for the HTTP tunnel (empty to use the host)")
+	mcpCmd.Flags().Int("port", 8070, "Port to bind to")
+	mcpCmd.Flags().Bool("stdio", false, "Use standard input/output for communication")
+	mcpCmd.Flags().Bool("tunnel", false, "Use an HTTP tunnel, and expose the server to the internet (when used, --host, --domain and --port are ignored)")
+	mcpCmd.Flags().StringP("database", "d", "", "Database to connect to (a path or :memory:)")
+	mcpCmd.Flags().Bool("in-memory", false, "Use an in-memory database")
+	mcpCmd.Flags().Bool("readonly", false, "Open the SQLite database in read-only mode")
+	mcpCmd.Flags().Bool("read-only", false, "Open the SQLite database in read-only mode")
+	mcpCmd.Flags().StringSlice("extension", []string{}, "Load one or more extensions by specifying their path. Separate multiple extensions with a comma.")
+	mcpCmd.Flags().String("log-file", "", "Log file")
+	mcpCmd.Flags().String("log-level", "info", "Log level (trace, debug, info, warn, error, off)")
+	mcpCmd.Flags().String("log-format", "text", "Log format (text, json)")
+
+}

controller/config/database.go

@@ -3,6 +3,7 @@ package config
 
 import (
 	"database/sql"
+	"fmt"
 	"os"
 
 	_ "embed"
@@ -61,6 +62,12 @@ func OpenDatabaseConnection(path string, readOnly bool) (*sql.DB, *model.Queries
 		return nil, nil, err
 	}
 
+	// Apply the migrations in migrations.go
+	err = applyMigrations(db)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to apply migrations: %w", err)
+	}
+
 	// We create the querier
 	querier := model.New(db)
 

controller/config/migrations.go

@@ -0,0 +1,102 @@
+package config
+
+import (
+	"database/sql"
+	"fmt"
+	"slices"
+)
+
+type migration struct {
+	// The version of the migration
+	Version int
+	// The description of the migration
+	Description string
+	// The SQL queries to run for the migration
+	Queries []string
+
+	// A check to see if the migration has already been applied
+	// This is used to skip migrations that have already been applied
+	// If this is nil, the migration will always be applied
+	Check func(db *sql.DB) (bool, error)
+}
+
+var migrations = []migration{
+	{
+		Version:     1,
+		Description: "Add column tableMetadata to plugin_installed",
+		Queries: []string{
+			`ALTER TABLE plugin_installed ADD COLUMN tableMetadata TEXT DEFAULT '{}' NOT NULL`,
+		},
+		Check: func(db *sql.DB) (bool, error) {
+			var count int
+			err := db.QueryRow("SELECT COUNT(*) FROM pragma_table_info('plugin_installed') WHERE name = 'tableMetadata'").Scan(&count)
+			if err != nil {
+				return false, err
+			}
+
+			return count > 0, nil
+		},
+	},
+}
+
+// Apply migrations to the database
+// unless they have already been applied
+func applyMigrations(db *sql.DB) error {
+	// Sort the migrations by semver
+	slices.SortStableFunc(migrations, func(i, j migration) int {
+		return i.Version - j.Version
+	})
+
+	// Get the current version
+	var version int
+	err := db.QueryRow("PRAGMA user_version").Scan(&version)
+	if err != nil {
+		return fmt.Errorf("failed to get current database version: %w", err)
+	}
+
+	// Apply the migrations
+	for _, m := range migrations {
+		if version >= m.Version {
+			continue
+		}
+
+		if m.Check != nil {
+			alreadyApplied, err := m.Check(db)
+			if err != nil {
+				return fmt.Errorf("failed to check if migration %d has already been applied: %w", m.Version, err)
+			}
+
+			if alreadyApplied {
+				continue
+			}
+		}
+
+		tx, err := db.Begin()
+		if err != nil {
+			return fmt.Errorf("failed to start transaction for migration %d: %w", m.Version, err)
+		}
+
+		for _, q := range m.Queries {
+			_, err := tx.Exec(q)
+			if err != nil {
+				tx.Rollback()
+				return fmt.Errorf("failed to apply migration %d: %w", m.Version, err)
+			}
+		}
+
+		_, err = tx.Exec(fmt.Sprintf("PRAGMA user_version = %d", m.Version))
+		if err != nil {
+			tx.Rollback()
+			return fmt.Errorf("failed to update database version: %w", err)
+		}
+
+		err = tx.Commit()
+		if err != nil {
+			return fmt.Errorf("failed to commit transaction for migration %d: %w", m.Version, err)
+		}
+
+		version = m.Version
+	}
+
+	return nil
+}