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, 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 example. You can either pull it directly or initialize it step by step to 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 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 tool provided for checking MCP server functionality.

// 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 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 whether 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 tool list
const tools = await client.listTools();
console.log("Tools:", tools);

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

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

After writing the MCP client, compile the ts and run the MCP client. 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 Request to Deepseek to Call MCP#

Deepseek can use the OpenAI SDK to send requests. When sending requests, include the tools in the parameters. Since the definition of the Tools parameter in OpenAI differs from that in 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 resend the obtained result to Deepseek, and Deepseek will successfully retrieve the information from the database.

const openai = new OpenAI({
  apiKey: 'apikey',  // Use your api key, preferably 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 tool calls    
      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 another request. You can include tools in this request to achieve 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 command 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 for improvement.

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 one round of tool calls and cannot achieve multi-turn calls. Allowing MCP multi-turn calls can better leverage its 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 an issue.