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 request DeepSeek, implementing a simple Sqlite MCP from server to client, 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 either pull it directly or initialize it step by step to create your own database.

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#

The MCP Server can be started in two ways: Stdio and 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 tool's purpose 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. The inspector is an official MCP server inspection tool to check if the server service is functioning properly.

// Compile ts
npm run build

// Run the 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 to handle 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 to handle 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, you also need to compile it and run the express service, 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 types of transport: stdio and 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 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 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 to StdioTransport and SSETransport, but it seems 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 in the parameters 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 to 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, including 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 to 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 it back 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 obtained 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, the simplest MCP process has been completed, and there are many areas that can be improved.

This process provides the simplest SQL query function. 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, only one round of tool calls is supported, and multi-turn calls are not possible. Allowing MCP multi-turn calls can better leverage MCP's capabilities.
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.