Run the first MCP with TypeScript, using Deepseek to query the sqlite database.

The hottest AI technology recently should be MCP. If you are not familiar with the concept of MCP, it is recommended to check the Model Context Protocol documentation, which details the concept and specifications of MCP. This article uses the official TypeScript SDK to make requests to DeepSeek, implementing a simple Sqlite MCP from server to client, and successfully starting MCP development.

Initialize Project#

All resources for this project are in this git repository TypeScript-MCP-Sqlite-Quickstart, which includes the sqlite files used in the examples. You can pull it directly or follow the steps to initialize and create a database yourself.

Create Project

Create folder
mkdir TypeScript-MCP-Sqlite-Quickstart
cd TypeScript-MCP-Sqlite-Quickstart

Initialize npm
npm init -y

Install dependencies
npm install @modelcontextprotocol/sdk zod sqlite3 express @types/express openai
npm install -D @types/node typescript

touch index.ts
touch server/sqlite_stdio.ts
touch server/sqlite_sse.ts

Configure package.json and tsconfig.json package.json

{
  "name": "typescript-mcp-sqlite-quickstart",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc && chmod 755 build/index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "module",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.8.0",
    "@types/express": "^5.0.1",
    "express": "^5.1.0",
    "openai": "^4.91.1",
    "sqlite3": "^5.1.7",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/node": "^22.13.17",
    "typescript": "^5.8.2"
  }
}

tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["index.ts","server/**/*"],
  "exclude": ["node_modules"]
}

Write MCP Server#

There are two ways to start the MCP Server: one is Stdio and the other is SSE, both of which will be introduced in this section. First, let's introduce the Stdio method.

Stdio Transport#

Add the following to the ./server/sqlite_stdio.ts file:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import sqlite3 from "sqlite3";
import { promisify } from "util";
import { z } from "zod";

// Create an MCPServer instance
export const sqliteServer = new McpServer({
  name: "SQLite Explorer",
  version: "1.0.0"
});

// Initialize Sqlite
const getDb = () => {
  const db = new sqlite3.Database("database.db");
  return {
    all: promisify<string, any[]>(db.all.bind(db)),
    close: promisify(db.close.bind(db))
  };
};

// Define a server
// The first parameter is the tool name
// The second parameter is the description, introducing the purpose of the tool to the large model
// The third parameter is the input parameters
// The fourth parameter is the method to call
sqliteServer.tool(
  "query",
  "This is a tool for executing SQLite queries. You can use it to execute any valid SQL query, such as SELECT sql FROM sqlite_master WHERE type='table', or SELECT * FROM table_name.",
  { sql: z.string() },
  async ({ sql }) => {
    const db = getDb();
    try {
      const results = await db.all(sql);
      return {
        content: [{
          type: "text",
          text: JSON.stringify(results, null, 2)
        }]
      };
    } catch (err: unknown) {
      const error = err as Error;
      return {
        content: [{
          type: "text",
          text: `Error: ${error.message}`
        }],
        isError: true
      };
    } finally {
      await db.close();
    }
  }
);

// Use StdioTransport to connect to the Server
const transport = new StdioServerTransport();
await sqliteServer.connect(transport);

Use build to compile the ts files, and inspector is an official MCP server inspection tool to check if the server service is functioning properly.

// Compile ts
npm run build

// Run inspection tool
npx @modelcontextprotocol/inspector

Stdio Result

SSE Transport#

Add the following to ./server/sqlite_sse.ts:

import express, { Request, Response } from "express";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import sqlite3 from "sqlite3";
import { promisify } from "util";
import { z } from "zod";

// Initialize an MCPServer instance
const sqliteServer = new McpServer({
  name: "SQLite Explorer",
  version: "1.0.0"
});

// Initialize Sqlite
const getDb = () => {
  const db = new sqlite3.Database("database.db");
  return {
    all: promisify<string, any[]>(db.all.bind(db)),
    close: promisify(db.close.bind(db))
  };
};

const app = express();

// Define a server, this part is the same as stdio
sqliteServer.tool(
  "query",
  "This is a tool for executing SQLite queries. You can use it to execute any valid SQL query, such as SELECT sql FROM sqlite_master WHERE type='table', or SELECT * FROM table_name.",
  { sql: z.string() },
  async ({ sql }) => {
    const db = getDb();
    try {
      const results = await db.all(sql);
      return {
        content: [{
          type: "text",
          text: JSON.stringify(results, null, 2)
        }]
      };
    } catch (err: unknown) {
      const error = err as Error;
      return {
        content: [{
          type: "text",
          text: `Error: ${error.message}`
        }],
        isError: true
      };
    } finally {
      await db.close();
    }
  }
);

// Use SSETransport to connect to the Server
const transports: {[sessionId: string]: SSEServerTransport} = {};

// Route for handling SSE connections
app.get("/sse", async (_: Request, res: Response) => {
  const transport = new SSEServerTransport('/messages', res);
  transports[transport.sessionId] = transport;
  res.on("close", () => {
    delete transports[transport.sessionId];
  });
  await sqliteServer.connect(transport);
});

// Route for handling multiple connections
app.post("/messages", async (req: Request, res: Response) => {
  const sessionId = req.query.sessionId as string;
  const transport = transports[sessionId];
  if (transport) {
    await transport.handlePostMessage(req, res);
  } else {
    res.status(400).send('No transport found for sessionId');
  }
});

app.listen(3001);

After completing the server writing, it also needs to be compiled, and the express service needs to be run. Then use Inspector to connect and test if the functionality is normal.

// Compile ts
npm run build

// Run express
node ./build/server/sqlite_sse.js

Open Inspector, select transport type as sse, set the URL to http://localhost:3001/sse, click connect, and test the tool.

#

SSE Test Result

Write MCP Client#

The MCP client also supports two transports: one is stdio and the other is sse, corresponding to the server. Add the following to index.ts:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Use StdioTransport to connect to the Server
// The parameters filled in here are consistent with those filled in the Inspector test
const stdioTransport = new StdioClientTransport({
  command: "node",
  args: ["./build/server/sqlite_stdio.js"]
});

// Use SSETransport to connect to the Server
// The parameters filled in here are consistent with those filled in the Inspector test
//const sseTransport = new SSEClientTransport(new URL("http://localhost:3001/sse"));

const client = new Client(
  {
    name: "example-client",
    version: "1.0.0"
  },
  {
    capabilities: {
      prompts: {},
      resources: {},
      tools: {}
    }
  }
);

// Connect StdioTransport and SSETransport, but it seems that only one can be connected at a time,
// choose the connection method as needed
await client.connect(stdioTransport);
// await client.connect(sseTransport);

// Get the list of tools
const tools = await client.listTools();
console.log("Tools:", tools);

// Get the list of resources
// const resources = await client.listResources();

// Get the list of prompts
// const prompts = await client.listPrompts();

After writing the MCP client, compile the ts, run the MCP client, and if the available tool list is listed, it indicates that the client is running normally.

// Compile ts
npm run build

// Run client
node build/index.js

#

MCP Client Query Tools Result

Send Requests to Deepseek to Call MCP#

Deepseek can use the OpenAI SDK to send requests, including the tools parameter when sending requests. Since the Tools parameter definition of OpenAI is different from that of Anthropic, convert it as needed after obtaining the tools. Conversion Function

const toolsResult = await client.listTools();

// Tools in Anthropic format
const anthropicTools = toolsResult.tools.map((tool) => {
        return {
          name: tool.name,
          description: tool.description,
          input_schema: tool.inputSchema,
        };
});

// Tools in OpenAI format
const openaiTools = toolsResult.tools.map((tool) => {
        return {
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description,
                "input_schema": tool.inputSchema,
            }
        }
})

At this point, the tools information has been successfully obtained. Just include the tools parameter when requesting Deepseek, and listen for the finish_reason in the response. If it is tools_calls, get the name and args from toll_calls in the response. Then call the MCP client's callTool method to send the obtained result back to Deepseek, and Deepseek will successfully retrieve the information from the database.

const openai = new OpenAI({
  apiKey: 'apikey',  // Use your api key, recommended to read from environment variables
  baseURL: 'https://api.deepseek.com/v1',
});

// Replace with your question
const messages: ChatCompletionMessageParam[] = [{ role: "user", content: "I have a sqlite database with expenses and incomes tables. Tell me how much my income and expenses are?" }];

// Send the first request with the tools parameter
const response = await openai.chat.completions.create({
        model: "deepseek-chat",
        messages: messages,
        max_tokens: 1000,
        tools: openaiTools,
  }
);

const content = response.choices[0];
// Listen for finish_reason. If it is tool_calls, it means the large model called the tool
console.log("finish_reason",content.finish_reason);
if (content.finish_reason === "tool_calls" && content.message.tool_calls && content.message.tool_calls.length > 0) {
    // Get the parameters returned by the large model for the tool call    
      const tool_call = content.message.tool_calls[0];
      const toolName = tool_call.function.name;
      const toolArgs = JSON.parse(tool_call.function.arguments) as { [x: string]: unknown } | undefined;


      const result = await client.callTool({
        name: toolName,
        arguments: toolArgs,
      });

      console.log(`[Large model called tool ${toolName} with parameters ${JSON.stringify(toolArgs)}]`)

      // Add the obtained result to messages, preparing to send to the large model 
      messages.push({
        role: "user",
        content: result.content as string,
      });

      // Add the obtained result to messages, and send the request again. You can include tools in this request for multi-turn calls, but better process logic is also needed.
      const response = await openai.chat.completions.create({
        model: "deepseek-chat",
        max_tokens: 1000,
        messages,
      });

    console.log(response.choices[0].message.content);
}

At this point, Deepseek has successfully retrieved database information through MCP. Use the following commands to check the call status.

// Compile ts
npm run build

// Run index.js
node  ./build/index.js

Run Result

Next Steps#

At this point, a very simple MCP process has been completed, and there are many areas that can be improved.

This process provides the simplest SQL query functionality. The server description is also relatively rough, and the large model may not successfully call the tool every time.
The current request method is non-streaming and can be improved to streaming.
Currently, it only supports single-turn tool calls and cannot achieve multi-turn calls. Allowing MCP multi-turn calls can better leverage MCP's capabilities.
Currently, it seems that a single client only supports connecting to one server. In the case of multiple services, how to efficiently manage clients is also a problem.