db4app-mcp-server 0.1.5 → 0.1.7

package/README.md

@@ -1,6 +1,6 @@
 # db4app-mcp-server
 
-MCP server for db4.app - enables LLMs to interact with browser-based Postgres databases via Model Context Protocol.
+MCP server for db4.app - enables LLMs to interact with browser-based Postgres databases via Model Context Protocol using the Postgres TCP protocol.
 
 ## Installation
 
@@ -16,6 +16,8 @@ npx db4app-mcp-server
 
 ## Usage
 
+**Important**: This MCP server uses the **Postgres TCP protocol** to connect directly to your browser database, just like `psql` or other Postgres clients. It uses TLS encryption and password authentication.
+
 ### With LM Studio
 
 1. Locate your `mcp.json` file:
@@ -23,7 +25,12 @@ npx db4app-mcp-server
    - **Windows:** `%APPDATA%\LM Studio\mcp.json`
    - **Linux:** `~/.config/LM Studio/mcp.json`
 
-2. Add this to the `mcpServers` object in your `mcp.json`:
+2. **Get your Connection ID and Auth Token**:
+   - Open the Database page in your browser
+   - Your **Connection ID** is displayed in the Connection Info section
+   - Your **Auth Token** is also shown in the Connection Info section (this is your password)
+
+3. Add this to the `mcpServers` object in your `mcp.json`:
 
 ```json
 {
@@ -32,35 +39,39 @@ npx db4app-mcp-server
       "command": "npx",
       "args": [
         "-y",
-        "db4app-mcp-server"
+        "db4app-mcp-server@0.1.6"
       ],
       "env": {
-        "MCP_RELAY_HTTP_URL": "http://localhost:8787/query",
+        "MCP_POSTGRES_URL": "postgres://postgres:YOUR_AUTH_TOKEN@YOUR_CONNECTION_ID.pg.db4.app",
         "LM_STUDIO_EMBEDDING_URL": "http://localhost:1234/v1/embeddings",
         "LM_STUDIO_EMBEDDING_MODEL": "text-embedding-qwen3-embedding-4b",
-        "MCP_ALLOWED_TABLES": "rag_mcp.documents",
-        "MCP_PUBLIC_KEY": "YOUR_PUBLIC_KEY_HERE",
-        "MCP_USE_ENCRYPTION": "true"
+        "MCP_SCHEMA": "rag_mcp"
       }
     }
   }
 }
 ```
 
-**Note**: Replace `YOUR_PUBLIC_KEY_HERE` with your actual public key from the Database page → Management tab → Encryption section.
+**Note**: 
+- Replace `YOUR_AUTH_TOKEN` with your actual auth token from step 2
+- Replace `YOUR_CONNECTION_ID` with your Connection ID from step 2
+- The connection string format is: `postgres://postgres:AUTH_TOKEN@CONNECTION_ID.pg.db4.app`
+- **Postgres TCP Protocol**: This server uses the standard Postgres wire protocol with TLS encryption, just like `psql` or DBeaver
 
-3. **Install an Embedding Model** (Required for RAG features):
+4. **Install an Embedding Model** (Required for RAG features):
    - Open LM Studio → Search tab
    - Search for embedding models (e.g., "bge", "e5", "text-embedding")
    - Download and load an embedding-capable model
    - Update `LM_STUDIO_EMBEDDING_MODEL` in your `mcp.json` with the exact model name
    - Enable headless server mode in LM Studio
 
-4. Restart LM Studio to load the configuration.
+5. Restart LM Studio to load the configuration.
 
 ### With Claude Desktop
 
-Add to your `claude_desktop_config.json`:
+1. **Get your Connection ID and Auth Token** (same as LM Studio setup above)
+
+2. Add to your `claude_desktop_config.json`:
 
 ```json
 {
@@ -69,66 +80,76 @@ Add to your `claude_desktop_config.json`:
       "command": "npx",
       "args": [
         "-y",
-        "db4app-mcp-server"
+        "db4app-mcp-server@0.1.6"
       ],
       "env": {
-        "MCP_RELAY_HTTP_URL": "http://localhost:8787/query",
+        "MCP_POSTGRES_URL": "postgres://postgres:YOUR_AUTH_TOKEN@YOUR_CONNECTION_ID.pg.db4.app",
         "LM_STUDIO_EMBEDDING_URL": "http://localhost:1234/v1/embeddings",
         "LM_STUDIO_EMBEDDING_MODEL": "text-embedding-qwen3-embedding-4b",
-        "MCP_ALLOWED_TABLES": "rag_mcp.documents",
-        "MCP_PUBLIC_KEY": "YOUR_PUBLIC_KEY_HERE",
-        "MCP_USE_ENCRYPTION": "true"
+        "MCP_SCHEMA": "rag_mcp"
       }
     }
   }
 }
 ```
 
-**Note**: Replace `YOUR_PUBLIC_KEY_HERE` with your actual public key from the Database page → Management tab → Encryption section.
+**Note**: 
+- Replace `YOUR_AUTH_TOKEN` with your actual auth token
+- Replace `YOUR_CONNECTION_ID` with your Connection ID
+- The connection string format is: `postgres://postgres:AUTH_TOKEN@CONNECTION_ID.pg.db4.app`
 
 ## Configuration
 
 All configuration is done via environment variables:
 
-- `MCP_RELAY_HTTP_URL` - HTTP relay endpoint (default: `http://localhost:8787/query`)
+- `MCP_POSTGRES_URL` - **Required**: Postgres connection string. Format: `postgres://postgres:AUTH_TOKEN@CONNECTION_ID.pg.db4.app`. Get your Connection ID and Auth Token from the Database page → Connection Info section.
+- `MCP_CONNECTION_ID` - **Optional**: Browser connection ID. Used to construct connection URL if `MCP_POSTGRES_URL` is not provided (requires `MCP_AUTH_TOKEN`).
+- `MCP_AUTH_TOKEN` - **Optional**: Auth token for authentication. Used to construct connection URL if `MCP_POSTGRES_URL` is not provided (requires `MCP_CONNECTION_ID`).
 - `LM_STUDIO_EMBEDDING_URL` - LM Studio embedding API endpoint (default: `http://localhost:1234/v1/embeddings`)
 - `LM_STUDIO_EMBEDDING_MODEL` - Optional model name for embeddings
-- `MCP_ALLOWED_TABLES` - **Required for recipes**: Comma-separated list of allowed tables (e.g., `"schema.table1,schema.table2"`). The relay validates all SQL queries against this whitelist. If not set, the MCP server can access all tables (for direct use, not recommended for recipes).
-- `MCP_PUBLIC_KEY` - **Optional**: Base64-encoded public key for end-to-end encryption. If not provided, the MCP server will attempt to fetch it from the relay's `/public-key` endpoint. Get your public key from the Database page → Management tab → Encryption section.
-- `MCP_USE_ENCRYPTION` - Enable end-to-end encryption (default: `true` if `MCP_PUBLIC_KEY` is set, otherwise `false`). When enabled, all SQL queries are encrypted with RSA-OAEP before being sent to the relay, ensuring the relay cannot decrypt them.
+- `MCP_SCHEMA` - **Optional**: Schema name for RAG functions (`remember`, `search_memory`). Defaults to `public`. For recipes, set this to the recipe's schema (e.g., `rag_mcp`).
 
-## Available Tools
+**Note**: This MCP server uses the **Postgres TCP protocol** with TLS encryption, just like standard Postgres clients. No HTTP or RSA-OAEP encryption is used.
 
-- `query_database` - Execute SQL queries (respects `MCP_ALLOWED_TABLES` if set)
-- `list_tables` - List tables in the database (only shows whitelisted tables if `MCP_ALLOWED_TABLES` is set)
-- `remember` - Store information in memory with automatic embedding (requires `MCP_ALLOWED_TABLES` for recipe use)
-- `search_memory` - Search through stored memories using semantic similarity (requires `MCP_ALLOWED_TABLES` for recipe use)
-
-**Note**: When used with recipes, `MCP_ALLOWED_TABLES` must be set to restrict access to only the recipe's tables. The relay server validates all queries against this whitelist.
-
-## End-to-End Encryption
+## Available Tools
 
-This MCP server supports end-to-end encryption of SQL queries using RSA-OAEP (2048-bit). When encryption is enabled:
+- `query_database` - Execute SQL queries against the database
+- `list_tables` - List tables in the database
+- `remember` - Store information in memory with automatic embedding (uses `MCP_SCHEMA` for the target schema)
+- `search_memory` - Search through stored memories using semantic similarity (uses `MCP_SCHEMA` for the target schema)
 
-- SQL queries are encrypted in the MCP server using the browser's public key
-- The relay server relays encrypted queries without being able to decrypt them
-- Only the browser (with the private key) can decrypt and execute queries
-- This ensures complete privacy: even the relay cannot see your SQL queries
+## Security
 
-To enable encryption:
-1. Get your public key from the Database page → Management tab → Encryption section
-2. Set `MCP_PUBLIC_KEY` to your public key (base64 string)
-3. Set `MCP_USE_ENCRYPTION` to `"true"`
+This MCP server uses the standard Postgres TCP protocol with:
+- **TLS encryption**: All connections are encrypted using TLS (same as `psql` with SSL)
+- **Password authentication**: Uses the auth token as the password
 
-If `MCP_PUBLIC_KEY` is not provided, the MCP server will automatically fetch it from the relay's `/public-key` endpoint.
+**Note**: With password authentication, anyone with the auth token can connect with any Postgres client and access all tables. The security model relies on:
+- Not sharing the auth token
+- Schema isolation (recipes operate in their own schemas)
+- Standard Postgres access control (if you have the password, you have access)
 
 ## Requirements
 
 - Node.js 18+
-- Postgres WASM relay running (default: `http://localhost:8787/query`)
+- Browser tab with db4.app open and relay connected
+- Connection ID and Auth Token from the Database page
 - For RAG features: LM Studio with embedding-capable model loaded
 
+## Connection String Format
+
+The connection string follows the standard Postgres URL format:
+
+```
+postgres://postgres:AUTH_TOKEN@CONNECTION_ID.pg.db4.app
+```
+
+Where:
+- `postgres` is the username (fixed)
+- `AUTH_TOKEN` is your auth token (password)
+- `CONNECTION_ID` is your connection ID (hostname)
+- Port defaults to 5432 (standard Postgres port)
+
 ## License
 
 MIT
-

package/dist/index.js

@@ -14658,57 +14658,105 @@ var StdioServerTransport = class {
 };
 
 // src/index.js
-import { webcrypto } from "node:crypto";
-var DEFAULT_RELAY_URL = process.env.MCP_RELAY_HTTP_URL ?? process.env.MCP_PROXY_HTTP_URL ?? "http://localhost:8787/query";
+import pg from "pg";
+var { Client } = pg;
+var DEFAULT_POSTGRES_URL = process.env.MCP_POSTGRES_URL ?? null;
 var DEFAULT_EMBEDDING_URL = process.env.LM_STUDIO_EMBEDDING_URL ?? "http://localhost:1234/v1/embeddings";
 var DEFAULT_EMBEDDING_MODEL = process.env.LM_STUDIO_EMBEDDING_MODEL ?? "";
-var MCP_PUBLIC_KEY = process.env.MCP_PUBLIC_KEY ?? null;
-var USE_ENCRYPTION = process.env.MCP_USE_ENCRYPTION === "true" || MCP_PUBLIC_KEY !== null;
 var MCP_CONNECTION_ID = process.env.MCP_CONNECTION_ID ?? null;
+var MCP_AUTH_TOKEN = process.env.MCP_AUTH_TOKEN ?? null;
+var MCP_SCHEMA = process.env.MCP_SCHEMA ?? "public";
+var clientPool = /* @__PURE__ */ new Map();
+function getClient(postgresUrl) {
+  if (!postgresUrl) {
+    throw new Error("Postgres connection URL is required. Set MCP_POSTGRES_URL or pass postgresUrl in the tool call.");
+  }
+  if (clientPool.has(postgresUrl)) {
+    return clientPool.get(postgresUrl);
+  }
+  const client = new Client({
+    connectionString: postgresUrl,
+    ssl: postgresUrl.includes("db4.app") ? { rejectUnauthorized: true } : false
+  });
+  clientPool.set(postgresUrl, client);
+  return client;
+}
+async function ensureConnected(client) {
+  if (client._connected || client._ending) {
+    return;
+  }
+  if (!client._connected) {
+    const connectPromise = client.connect();
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Postgres connection timed out after 10 seconds")), 1e4)
+    );
+    await Promise.race([connectPromise, timeoutPromise]);
+  }
+}
 var mcpServer = new McpServer({
   name: "db4app-bridge",
-  version: "0.1.0"
+  version: "0.2.0"
 });
 var RunSqlSchema = external_exports.object({
   sql: external_exports.string().min(1).describe("SQL statement to execute against the browser-backed Postgres engine"),
   params: external_exports.array(external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.null()])).describe("Optional positional parameters for the SQL statement").optional(),
-  relayUrl: external_exports.string().url().describe("Override the HTTP relay endpoint (defaults to MCP_RELAY_HTTP_URL or http://localhost:8787/query)").optional(),
-  connectionId: external_exports.string().uuid().describe("Browser connection ID (required for multi-user support, defaults to MCP_CONNECTION_ID)").optional()
+  postgresUrl: external_exports.string().url().describe("Override the Postgres connection URL (defaults to MCP_POSTGRES_URL). Format: postgres://postgres:AUTH_TOKEN@CONNECTION_ID.pg.db4.app").optional(),
+  connectionId: external_exports.string().uuid().describe("Browser connection ID (used to construct connection URL if postgresUrl not provided, defaults to MCP_CONNECTION_ID)").optional(),
+  authToken: external_exports.string().describe("Auth token for authentication (used to construct connection URL if postgresUrl not provided, defaults to MCP_AUTH_TOKEN)").optional()
 });
 var ListTablesSchema = external_exports.object({
   schema: external_exports.string().describe("Schema name to filter by (default: public)").optional(),
-  relayUrl: external_exports.string().url().describe("Override the HTTP relay endpoint (defaults to MCP_RELAY_HTTP_URL or http://localhost:8787/query)").optional(),
-  connectionId: external_exports.string().uuid().describe("Browser connection ID (required for multi-user support, defaults to MCP_CONNECTION_ID)").optional()
+  postgresUrl: external_exports.string().url().describe("Override the Postgres connection URL (defaults to MCP_POSTGRES_URL)").optional(),
+  connectionId: external_exports.string().uuid().describe("Browser connection ID (used to construct connection URL if postgresUrl not provided)").optional(),
+  authToken: external_exports.string().describe("Auth token for authentication (used to construct connection URL if postgresUrl not provided)").optional()
 });
 var RememberSchema = external_exports.object({
   content: external_exports.string().min(1).describe("Information to remember and store in memory. This will be automatically embedded and indexed for semantic search."),
   source: external_exports.string().describe('Optional source identifier for this memory (e.g. "conversation", "user_input", file path)').optional(),
   metadata: external_exports.record(external_exports.string(), external_exports.unknown()).describe("Optional metadata to store alongside the memory (JSON object).").optional(),
-  relayUrl: external_exports.string().url().describe("Override the HTTP relay endpoint (defaults to MCP_RELAY_HTTP_URL or http://localhost:8787/query)").optional(),
+  postgresUrl: external_exports.string().url().describe("Override the Postgres connection URL (defaults to MCP_POSTGRES_URL)").optional(),
   embeddingUrl: external_exports.string().url().describe("Override the LM Studio embedding endpoint (defaults to LM_STUDIO_EMBEDDING_URL or http://localhost:1234/v1/embeddings)").optional(),
   embeddingModel: external_exports.string().describe("Optional model name for embedding generation (defaults to LM_STUDIO_EMBEDDING_MODEL)").optional(),
-  connectionId: external_exports.string().uuid().describe("Browser connection ID (required for multi-user support, defaults to MCP_CONNECTION_ID)").optional()
+  connectionId: external_exports.string().uuid().describe("Browser connection ID (used to construct connection URL if postgresUrl not provided)").optional(),
+  authToken: external_exports.string().describe("Auth token for authentication (used to construct connection URL if postgresUrl not provided)").optional()
 });
 var SemanticSearchSchema = external_exports.object({
   query: external_exports.string().min(1).describe("Natural language query for semantic search"),
   embedding: external_exports.array(external_exports.number()).nonempty().describe("Embedding for the query. If not provided, will be computed automatically using LM Studio.").optional(),
   topK: external_exports.number().int().positive().max(100).describe("Maximum number of matching chunks to return").default(5),
   source: external_exports.string().describe("Optional source identifier to filter results by").optional(),
-  relayUrl: external_exports.string().url().describe("Override the HTTP relay endpoint (defaults to MCP_RELAY_HTTP_URL or http://localhost:8787/query)").optional(),
+  postgresUrl: external_exports.string().url().describe("Override the Postgres connection URL (defaults to MCP_POSTGRES_URL)").optional(),
   embeddingUrl: external_exports.string().url().describe("Override the LM Studio embedding endpoint (used only if embedding is not provided)").optional(),
   embeddingModel: external_exports.string().describe("Optional model name for embedding generation (used only if embedding is not provided)").optional(),
-  connectionId: external_exports.string().uuid().describe("Browser connection ID (required for multi-user support, defaults to MCP_CONNECTION_ID)").optional()
+  connectionId: external_exports.string().uuid().describe("Browser connection ID (used to construct connection URL if postgresUrl not provided)").optional(),
+  authToken: external_exports.string().describe("Auth token for authentication (used to construct connection URL if postgresUrl not provided)").optional()
 });
+function buildPostgresUrl(connectionId, authToken, providedUrl) {
+  if (providedUrl) {
+    return providedUrl;
+  }
+  const effectiveConnectionId = connectionId ?? MCP_CONNECTION_ID;
+  const effectiveAuthToken = authToken ?? MCP_AUTH_TOKEN;
+  if (!effectiveConnectionId || !effectiveAuthToken) {
+    if (DEFAULT_POSTGRES_URL) {
+      return DEFAULT_POSTGRES_URL;
+    }
+    throw new Error(
+      "Postgres connection URL is required. Either provide postgresUrl, set MCP_POSTGRES_URL, or provide both connectionId and authToken (or set MCP_CONNECTION_ID and MCP_AUTH_TOKEN)."
+    );
+  }
+  return `postgres://postgres:${encodeURIComponent(effectiveAuthToken)}@${effectiveConnectionId}.pg.db4.app`;
+}
 mcpServer.registerTool(
   "query_database",
   {
-    description: "Execute SQL queries against the database. Use this when you need to SELECT data, INSERT rows, UPDATE records, DELETE data, CREATE tables, or run any other SQL statement. This is the primary tool for interacting with the database schema and data. Note: This tool respects table permissions - you can only access tables specified in MCP_ALLOWED_TABLES.",
+    description: "Execute SQL queries against the database. Use this when you need to SELECT data, INSERT rows, UPDATE records, DELETE data, CREATE tables, or run any other SQL statement. This is the primary tool for interacting with the database schema and data.",
     inputSchema: RunSqlSchema
   },
-  async ({ sql, params = [], relayUrl, connectionId }) => {
+  async ({ sql, params = [], postgresUrl, connectionId, authToken }) => {
     try {
-      const allowedTables = process.env.MCP_ALLOWED_TABLES ? process.env.MCP_ALLOWED_TABLES.split(",").map((t) => t.trim()) : [];
-      const result = await executeSql(relayUrl ?? DEFAULT_RELAY_URL, sql, params, allowedTables, connectionId);
+      const url = buildPostgresUrl(connectionId, authToken, postgresUrl);
+      const result = await executeSql(url, sql, params);
       return formatToolResult(result);
     } catch (error) {
       return mcpServer.createToolError(error instanceof Error ? error.message : String(error));
@@ -14718,35 +14766,21 @@ mcpServer.registerTool(
 mcpServer.registerTool(
   "list_tables",
   {
-    description: "List tables in the database that you have access to. Use this when you need to discover what tables exist, explore the database schema, or find out what data is available before writing queries. Returns table names and their schemas. Note: Only shows tables you have permission to access.",
+    description: "List tables in the database. Use this when you need to discover what tables exist, explore the database schema, or find out what data is available before writing queries. Returns table names and their schemas.",
     inputSchema: ListTablesSchema
   },
-  async ({ schema, relayUrl, connectionId }) => {
-    const allowedTables = process.env.MCP_ALLOWED_TABLES ? process.env.MCP_ALLOWED_TABLES.split(",").map((t) => t.trim()) : [];
-    let sql = `
+  async ({ schema, postgresUrl, connectionId, authToken }) => {
+    const sql = `
       SELECT table_schema, table_name
       FROM information_schema.tables
       WHERE table_type = 'BASE TABLE'
         AND table_schema NOT IN ('pg_catalog', 'information_schema')
         AND ($1::text IS NULL OR table_schema = $1::text)
+      ORDER BY table_schema, table_name;
     `;
-    if (allowedTables.length > 0) {
-      const tableFilters = allowedTables.map((table, idx) => {
-        const [schemaName, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-        return `(table_schema = $${idx + 2}::text AND table_name = $${idx + 3}::text)`;
-      });
-      sql += ` AND (${tableFilters.join(" OR ")})`;
-    }
-    sql += ` ORDER BY table_schema, table_name;`;
-    const params = [schema ?? null];
-    if (allowedTables.length > 0) {
-      allowedTables.forEach((table) => {
-        const [schemaName, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-        params.push(schemaName, tableName);
-      });
-    }
     try {
-      const result = await executeSql(relayUrl ?? DEFAULT_RELAY_URL, sql, params, allowedTables, connectionId);
+      const url = buildPostgresUrl(connectionId, authToken, postgresUrl);
+      const result = await executeSql(url, sql, [schema ?? null]);
       return formatToolResult(result);
     } catch (error) {
       return mcpServer.createToolError(error instanceof Error ? error.message : String(error));
@@ -14759,18 +14793,18 @@ mcpServer.registerTool(
     description: 'Store information in long-term memory for later retrieval. Use this when the user tells you something they want you to remember, such as personal facts, preferences, context from previous conversations, or any information that should persist across sessions. Automatically generates embeddings and makes the content searchable via semantic search. Examples: "Remember that I prefer dark mode", "Remember that Max is from Sweden", "Remember my API key is...".',
     inputSchema: RememberSchema
   },
-  async ({ content, source = null, metadata = null, relayUrl, embeddingUrl, embeddingModel, connectionId }) => {
+  async ({ content, source = null, metadata = null, postgresUrl, embeddingUrl, embeddingModel, connectionId, authToken }) => {
     try {
       const embedding = await generateEmbedding(content, embeddingUrl, embeddingModel);
-      const allowedTables = process.env.MCP_ALLOWED_TABLES ? process.env.MCP_ALLOWED_TABLES.split(",").map((t) => t.trim()) : [];
-      const schema = allowedTables.length > 0 && allowedTables[0].includes(".") ? allowedTables[0].split(".")[0] : "public";
+      const schema = MCP_SCHEMA;
       const sql = `
         INSERT INTO ${schema}.documents (source, chunk_index, content, metadata, embedding)
         VALUES ($1, $2, $3, $4::jsonb, $5::double precision[])
         RETURNING id, source, chunk_index, content;
       `;
       const params = [source, null, content, metadata ? JSON.stringify(metadata) : null, embedding];
-      const result = await executeSql(relayUrl ?? DEFAULT_RELAY_URL, sql, params, allowedTables, connectionId);
+      const url = buildPostgresUrl(connectionId, authToken, postgresUrl);
+      const result = await executeSql(url, sql, params);
       const insertedRow = result.rows[0];
       return {
         content: [
@@ -14797,14 +14831,13 @@ mcpServer.registerTool(
     description: 'Search through previously stored memories and information using semantic similarity. Use this when the user asks about something you might have remembered earlier, or when you need to recall information from past conversations. Examples: "Where is Max from?", "What did I tell you about my preferences?", "What information do you have about X?". Automatically computes embeddings if not provided. Returns the most relevant stored information ranked by similarity.',
     inputSchema: SemanticSearchSchema
   },
-  async ({ query, embedding, topK, source = null, relayUrl, embeddingUrl, embeddingModel, connectionId }) => {
+  async ({ query, embedding, topK, source = null, postgresUrl, embeddingUrl, embeddingModel, connectionId, authToken }) => {
     try {
       let queryEmbedding = embedding;
       if (!queryEmbedding) {
         queryEmbedding = await generateEmbedding(query, embeddingUrl, embeddingModel);
       }
-      const allowedTables = process.env.MCP_ALLOWED_TABLES ? process.env.MCP_ALLOWED_TABLES.split(",").map((t) => t.trim()) : [];
-      const schema = allowedTables.length > 0 && allowedTables[0].includes(".") ? allowedTables[0].split(".")[0] : "public";
+      const schema = MCP_SCHEMA;
       const sql = `
       SELECT
         id,
@@ -14820,7 +14853,8 @@ mcpServer.registerTool(
       LIMIT $3::int;
     `;
       const params = [queryEmbedding, source, topK];
-      const result = await executeSql(relayUrl ?? DEFAULT_RELAY_URL, sql, params, allowedTables, connectionId);
+      const url = buildPostgresUrl(connectionId, authToken, postgresUrl);
+      const result = await executeSql(url, sql, params);
       result.command = "RAG_SEMANTIC_SEARCH";
       return formatToolResult(result);
     } catch (error) {
@@ -14838,12 +14872,32 @@ async function generateEmbedding(text, embeddingUrl, model) {
   }
   let response;
   try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
     response = await fetch(url, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify(requestBody)
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
     });
+    clearTimeout(timeoutId);
   } catch (fetchError) {
+    if (fetchError.name === "AbortError") {
+      throw new Error(
+        `Embedding request timed out after 30 seconds. This usually means:
+1. LM Studio is not responding (check if it's running)
+2. The model is not an embedding model (you need an embedding model, not a chat model)
+3. The embedding endpoint URL is incorrect
+
+Current URL: ${url}
+Model: ${model || DEFAULT_EMBEDDING_MODEL || "not specified"}
+
+Troubleshooting:
+- Make sure LM Studio headless server is running
+- Load an EMBEDDING model (e.g., "BAAI/bge-small-en-v1.5", "text-embedding-qwen3-embedding-4b")
+- Check the embedding endpoint URL (default: http://localhost:1234/v1/embeddings)`
+      );
+    }
     const baseMessage = fetchError instanceof TypeError && fetchError.message.includes("fetch") ? `Failed to connect to LM Studio embedding endpoint at ${url}` : `Network error calling LM Studio embedding API: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`;
     const suggestion = `
 
@@ -14873,144 +14927,26 @@ Troubleshooting:
   }
   throw new Error("Unexpected embedding response format from LM Studio");
 }
-async function importPublicKey(publicKeyString) {
-  const buffer = Buffer.from(publicKeyString, "base64");
-  return webcrypto.subtle.importKey(
-    "spki",
-    buffer,
-    {
-      name: "RSA-OAEP",
-      hash: "SHA-256"
-    },
-    true,
-    ["encrypt"]
-  );
-}
-async function encryptWithPublicKey(publicKey, data) {
-  const encoder = new TextEncoder();
-  const dataBuffer = encoder.encode(data);
-  const encrypted = await webcrypto.subtle.encrypt(
-    {
-      name: "RSA-OAEP"
-    },
-    publicKey,
-    dataBuffer
-  );
-  return Buffer.from(encrypted).toString("base64");
-}
-async function fetchPublicKey(relayUrl, connectionId) {
+async function executeSql(postgresUrl, sql, params = []) {
+  const client = getClient(postgresUrl);
   try {
-    const relayUrlObj = new URL(relayUrl);
-    const pathParts = relayUrlObj.pathname.split("/").filter(Boolean);
-    let effectiveConnectionId = connectionId;
-    if (pathParts.length >= 2 && (pathParts[1] === "query" || pathParts[1] === "public-key")) {
-      effectiveConnectionId = pathParts[0];
-    } else if (pathParts[0] === "query" && pathParts[1]) {
-      effectiveConnectionId = pathParts[1];
-    } else if (pathParts[0] === "public-key" && pathParts[1]) {
-      effectiveConnectionId = pathParts[1];
-    } else if (!effectiveConnectionId) {
-      effectiveConnectionId = MCP_CONNECTION_ID;
-    }
-    if (!effectiveConnectionId) {
-      throw new Error("Connection ID is required to fetch public key. Include it in MCP_RELAY_HTTP_URL as /{connectionId}/query or set MCP_CONNECTION_ID");
-    }
-    relayUrlObj.pathname = `/${effectiveConnectionId}/public-key`;
-    const publicKeyUrl = relayUrlObj.toString();
-    const response = await fetch(publicKeyUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch public key: ${response.status}`);
-    }
-    const data = await response.json();
-    return data.publicKey;
-  } catch (err) {
-    throw new Error(`Failed to fetch public key from relay: ${err.message}`);
-  }
-}
-var publicKeyCache = /* @__PURE__ */ new Map();
-async function getPublicKey(relayUrl, connectionId) {
-  const cacheKey = connectionId ?? "default";
-  if (publicKeyCache.has(cacheKey)) {
-    return publicKeyCache.get(cacheKey);
-  }
-  let publicKeyString = MCP_PUBLIC_KEY;
-  if (!publicKeyString) {
-    if (!connectionId && !MCP_CONNECTION_ID) {
-      throw new Error("Connection ID is required to fetch public key. Set MCP_CONNECTION_ID or pass connectionId.");
-    }
-    publicKeyString = await fetchPublicKey(relayUrl, connectionId ?? MCP_CONNECTION_ID);
-  }
-  const publicKey = await importPublicKey(publicKeyString);
-  publicKeyCache.set(cacheKey, publicKey);
-  return publicKey;
-}
-async function executeSql(relayUrl, sql, params, allowedTables, connectionId) {
-  if (!relayUrl) {
-    throw new Error("Relay URL is not set. Provide MCP_RELAY_HTTP_URL or pass relayUrl in the tool call.");
-  }
-  const relayUrlObj = new URL(relayUrl);
-  const pathParts = relayUrlObj.pathname.split("/").filter(Boolean);
-  let queryUrl = relayUrl;
-  let effectiveConnectionId = connectionId;
-  if (pathParts.length >= 2 && pathParts[1] === "query") {
-    effectiveConnectionId = pathParts[0];
-    queryUrl = relayUrl;
-  } else if (pathParts[0] === "query" && pathParts[1]) {
-    effectiveConnectionId = pathParts[1];
-    queryUrl = relayUrl;
-  } else {
-    effectiveConnectionId = connectionId ?? MCP_CONNECTION_ID;
-    if (!effectiveConnectionId) {
-      throw new Error(
-        "Connection ID is required. Either include it in MCP_RELAY_HTTP_URL as /{connectionId}/query, or set MCP_CONNECTION_ID environment variable, or pass connectionId in the tool call."
-      );
-    }
-    relayUrlObj.pathname = `/${effectiveConnectionId}/query`;
-    queryUrl = relayUrlObj.toString();
-  }
-  let requestBody;
-  if (USE_ENCRYPTION) {
-    try {
-      const publicKey = await getPublicKey(relayUrl, effectiveConnectionId);
-      const payloadToEncrypt = JSON.stringify({ sql, params });
-      const encryptedPayload = await encryptWithPublicKey(publicKey, payloadToEncrypt);
-      requestBody = {
-        encrypted: true,
-        encryptedPayload
-      };
-      if (allowedTables && allowedTables.length > 0) {
-        requestBody.allowedTables = allowedTables;
-      }
-    } catch (encryptErr) {
-      console.error("[MCP] Encryption failed, falling back to unencrypted:", encryptErr.message);
-      requestBody = { sql, params };
-      if (allowedTables && allowedTables.length > 0) {
-        requestBody.allowedTables = allowedTables;
-      }
-    }
-  } else {
-    requestBody = { sql, params };
-    if (allowedTables && allowedTables.length > 0) {
-      requestBody.allowedTables = allowedTables;
-    }
-  }
-  console.log("[MCP] Executing SQL:", { queryUrl, effectiveConnectionId, sql: sql.substring(0, 100) + "..." });
-  const response = await fetch(queryUrl, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(requestBody)
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => ({}));
-    const errorMessage = errorData.error ?? `Relay request failed (${response.status})`;
-    console.error("[MCP] Relay error:", { status: response.status, statusText: response.statusText, error: errorMessage, url: queryUrl });
-    throw new Error(errorMessage);
-  }
-  const payload = await response.json();
-  if (!payload.ok) {
-    throw new Error(payload.error ?? "Relay returned an error");
+    await ensureConnected(client);
+    console.log("[MCP] Executing SQL:", { postgresUrl: postgresUrl.replace(/:[^:@]+@/, ":****@"), sql: sql.substring(0, 100) + "..." });
+    const queryPromise = client.query(sql, params);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Postgres query timed out after 30 seconds")), 3e4)
+    );
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    return {
+      columns: result.fields?.map((f) => f.name) ?? [],
+      rows: result.rows ?? [],
+      command: result.command ?? "QUERY",
+      rowCount: result.rowCount ?? 0
+    };
+  } catch (error) {
+    console.error("[MCP] Postgres error:", error.message);
+    throw error;
   }
-  return payload.result ?? { columns: [], rows: [], command: "QUERY", rowCount: 0 };
 }
 function formatToolResult(result) {
   const { columns = [], rows = [], command = "QUERY", rowCount = rows.length ?? 0 } = result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "db4app-mcp-server",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "MCP server for db4.app - enables LLMs to interact with browser-based Postgres databases via Model Context Protocol",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "esbuild src/index.js --bundle --platform=node --format=esm --outfile=dist/index.js --external:node:*",
+    "build": "esbuild src/index.js --bundle --platform=node --format=esm --outfile=dist/index.js --external:node:* --external:pg --external:pg-native",
     "lint": "eslint src --ext .js",
     "prepublishOnly": "npm run build",
     "start": "node dist/index.js"
@@ -40,6 +40,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.22.0",
+    "pg": "^8.11.3",
     "zod": "^3.25.76"
   },
   "devDependencies": {