Complete MCP Configuration Guide: Enable Cursor to Query Databases and Call APIs Directly

Last Wednesday afternoon, I was working on a data analysis feature and needed to check how many new users joined in December. Following my old routine, I had to switch to DataGrip, write SQL, run it, copy the results, and paste them back into my code. For this simple query, I switched between three windows and wasted two minutes.

Then it hit me: I use Cursor every day to write code, and AI can already help me write functions and fix bugs—why can’t it query the database directly?

After configuring MCP, I now just ask in Cursor: “Check the number of new users in December,” and AI returns the result instantly. No window switching, no SQL writing. Efficiency doubled.

Honestly, when I first heard about MCP, I was confused for a while. Server, Client, Protocol—it sounded fancy, but online tutorials were either too theoretical (spending ages on architecture diagrams) or too shallow (just Hello World examples). I spent two days troubleshooting before figuring out the configuration.

So in this article, I want to use the most straightforward approach to teach you how to configure MCP, enabling AI to query databases and call APIs directly. 15 minutes to complete, ready to use immediately.

What is MCP and Why Do You Need It

Explaining MCP in Plain English

MCP stands for Model Context Protocol. Sounds academic, right? In simple terms, it’s like giving AI a “tool belt.”

Old AI was like a really smart consultant: you ask questions, it gives advice and writes code, but it can’t do anything itself. You have to copy its suggestions and execute them yourself.

With MCP, AI becomes a true assistant: it not only gives advice but can also do the work directly. Querying databases, calling APIs, reading files—it can handle all of these on its own.

Traditional Approach vs MCP Approach

Here’s a real example: you want to know which product had the highest sales last month.

Traditional approach (without MCP):

1. You: Ask AI to write a query SQL
2. AI: Gives you SQL code
3. You: Copy SQL, switch to database client
4. You: Paste SQL, execute
5. You: Copy query results
6. You: Switch back to Cursor, paste results to AI
7. AI: Continues analysis based on results

The entire process requires constant switching between three windows. Tedious.

MCP approach:

1. You: Directly ask AI “Which product had the highest sales last month?”
2. AI: Automatically queries database, tells you the answer directly

One step. At least 5x faster.

Core Concepts (Understand in 3 Minutes)

MCP’s architecture is actually simple, with three roles:

MCP Client (The AI Brain Using Tools)
The AI tool you’re using, like Cursor or Claude Desktop. It understands your needs and decides whether to use tools.

MCP Server (The Waiter Providing Tools)
The service you configure that provides specific capabilities to AI. For example, a database MCP Server lets AI query databases, while an API MCP Server lets AI call interfaces.

Tools (Specific Capabilities)
The specific functions each MCP Server exposes. For instance, a database Server might have tools like “query table structure,” “execute SELECT query,” “count rows.”

Think of it this way: AI is a worker (Client), MCP Server is a toolbox containing wrenches and hammers (Tools). When you say you need to hammer a nail, AI knows to grab the hammer from the toolbox.

Once you understand these three concepts, you’ll understand what the configuration is doing.

Case Study 1 - SQLite Database Integration

Why Start with SQLite

SQLite’s biggest advantage is simplicity: no database service installation, no port configuration, one file is one database. Perfect for practice.

Once you’re familiar with the process, switching to PostgreSQL or MySQL follows the same pattern.

Preparation: Create Test Database

First, create some data to test queries. Create a test.db file:

-- Create users table
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE,
    created_at TEXT DEFAULT CURRENT_TIMESTAMP
);

-- Create orders table
CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    user_id INTEGER,
    product_name TEXT,
    amount REAL,
    order_date TEXT DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- Insert test users
INSERT INTO users (name, email) VALUES
    ('Zhang San', 'zhangsan@example.com'),
    ('Li Si', 'lisi@example.com'),
    ('Wang Wu', 'wangwu@example.com');

-- Insert test orders
INSERT INTO orders (user_id, product_name, amount) VALUES
    (1, 'MacBook Pro', 12999.00),
    (1, 'AirPods', 1299.00),
    (2, 'iPhone 15', 5999.00),
    (3, 'iPad Air', 4799.00),
    (3, 'Apple Watch', 2999.00);

You can execute these SQL statements with any SQLite tool (DB Browser, command line, etc.), or directly use Python:

import sqlite3

conn = sqlite3.connect('test.db')
cursor = conn.cursor()

# Execute the SQL statements above
# ...

conn.commit()
conn.close()

Configuring MCP Server (The Key Part)

This is the core of the entire tutorial. The MCP configuration file can be in two locations, depending on your needs:

Global configuration (available to all projects):

• Windows: C:\Users\YourUsername\.cursor\mcp.json
• Mac/Linux: ~/.cursor/mcp.json

Project-level configuration (only effective in current project):

• .cursor/mcp.json in project root directory

I recommend starting with project-level configuration, and moving to global once you confirm it works.

Create .cursor/mcp.json file with the following content:

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "--db-path",
        "D:/path/to/your/test.db"
      ]
    }
  }
}

Key points explanation (many people get stuck here):

1. mcpServers: This is a fixed field name, don’t change it
2. "sqlite": This is the name you give this Server, name it anything, AI will see this name
3. command: "npx": Use npx to run MCP Server directly, no manual installation needed
4. args: Parameters passed to the command
   • -y: Auto-confirm installation
   • @modelcontextprotocol/server-sqlite: Official SQLite MCP Server package
   • --db-path: Database file path (must be absolute path!)

Windows users note: Use forward slashes / or double backslashes \\, not single backslashes:

• ✅ D:/projects/test.db
• ✅ D:\\\\projects\\\\test.db
• ❌ D:\projects\test.db (this will error)

Restart Cursor, Verify Configuration

After saving the configuration file, you must completely restart Cursor, not just close the window, but quit the application.

After restarting, you can check if MCP is working in Cursor settings:

1. Open settings (Ctrl+,)
2. Search for “MCP”
3. You should see your configured SQLite Server

Or a more direct method: directly ask AI a database-related question and see if it calls MCP.

Practical Demo

Once configured successfully, you can do this:

Query 1: Check what tables exist

You: What tables are in the database?
AI: [Calls MCP to query] There are two tables: users and orders

Query 2: Count users

You: Check how many users there are in total
AI: [Executes SELECT COUNT(*) FROM users] There are 3 users

Query 3: Check a user’s orders

Alibaba Cloud - Top choice for developers, exclusive 15% off for Lighthouse servers

Get 15% Discount →Ad

You: What did Zhang San buy?
AI: [Executes join query] Zhang San purchased:
- MacBook Pro (12,999 yuan)
- AirPods (1,299 yuan)
Total: 14,298 yuan

Query 4: Aggregate analysis

You: Which user spent the most?
AI: [Executes GROUP BY query] Zhang San spent the most, totaling 14,298 yuan

See? You don’t need to write SQL at all, AI handles it automatically. That’s the power of MCP.

Troubleshooting Common Issues

Issue 1: MCP Server didn’t start
Symptom: AI answers questions but doesn’t call database
Solution:

• Check configuration file syntax (JSON format must be correct, no extra commas)
• Confirm you completely restarted Cursor
• Check Cursor output logs, search for “MCP” related errors

Issue 2: Database file not found
Symptom: Error “cannot open database file”
Solution:

• Confirm path is absolute path, not relative path
• Windows users check slash direction
• Confirm file actually exists (ls or dir command to check)

Issue 3: Permission error
Symptom: Permission denied
Solution:

• Check database file read/write permissions
• Windows users: Right-click file → Properties → Security, confirm current user has read permission

Debugging tip: In VS Code (Cursor), open “Output” panel (View → Output), select “MCP” channel to see detailed error logs.

Case Study 2 - PostgreSQL Database Integration

Advanced Scenario: Production Database

SQLite is suitable for learning and small projects, but in real work, you might use production-grade databases like PostgreSQL or MySQL. The good news is the configuration pattern is the same, just different parameters.

I’ll use PostgreSQL as an example here; MySQL is similar.

Configuration Difference: Connection Info and Environment Variables

PostgreSQL has a client-server architecture and requires connection information. But never write passwords directly in the configuration file—this is the most common security mistake.

The correct approach is to use environment variables.

First create a .env file in the project root (remember to add to .gitignore):

POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_DATABASE=myapp
POSTGRES_USER=readonly_user
POSTGRES_PASSWORD=your_secure_password

Then configure .cursor/mcp.json:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "--stdio"
      ],
      "env": {
        "POSTGRES_HOST": "${POSTGRES_HOST}",
        "POSTGRES_PORT": "${POSTGRES_PORT}",
        "POSTGRES_DATABASE": "${POSTGRES_DATABASE}",
        "POSTGRES_USER": "${POSTGRES_USER}",
        "POSTGRES_PASSWORD": "${POSTGRES_PASSWORD}"
      }
    }
  }
}

Key points:

• --stdio: Communicates through standard input/output (local method)
• env: Environment variable configuration, Cursor automatically reads project’s .env file

Security Best Practices (Very Important)

Giving AI database access requires security first. The mistakes I’ve made, you don’t need to repeat:

1. Use Read-Only Account

Don’t give AI write permissions! If AI misunderstands your intent and executes DELETE or UPDATE, you’ll regret it.

Create read-only user:

-- Create read-only user
CREATE USER readonly_user WITH PASSWORD 'secure_password';

-- Grant only SELECT permission
GRANT CONNECT ON DATABASE myapp TO readonly_user;
GRANT USAGE ON SCHEMA public TO readonly_user;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly_user;

-- Ensure future tables also have only SELECT permission
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT ON TABLES TO readonly_user;

2. Limit Access Scope

If the database has sensitive tables (like user passwords, payment info), don’t let AI touch them:

-- Revoke access to sensitive tables
REVOKE SELECT ON TABLE user_passwords FROM readonly_user;
REVOKE SELECT ON TABLE payment_info FROM readonly_user;

3. Use Read Replicas in Production

If you really want to use MCP in production (I suggest not doing this initially), at least connect to a read replica (Read Replica), not the primary database. If AI’s query is too complex and brings down the database, at least it won’t affect the live service.

Practical Demo

Once configured, you can do things SQLite can’t:

Complex Query: Multi-table JOIN

You: Calculate average salary by department
AI: [Executes complex query]
SELECT d.name, AVG(e.salary) as avg_salary
FROM departments d
JOIN employees e ON d.id = e.department_id
GROUP BY d.name
ORDER BY avg_salary DESC;

Results:
- Tech Dept: Average 15,000 yuan
- Product Dept: Average 12,000 yuan
- Operations Dept: Average 10,000 yuan

Performance Analysis: View Execution Plan

You: Help me see why this query is so slow
AI: [Executes EXPLAIN] Found no index is used, suggests adding index on user_id field

Data Analysis: Generate Report

You: Daily new users for the past 7 days
AI: [Executes time window query]
2024-01-10: 45 users
2024-01-11: 52 users
...

Common Issues

Issue 1: Connection timeout
Symptom: timeout connecting to database
Solution:

Railway - Modern deployment platform, zero-config, go live in minutes

Start Now →Ad

• Check if database is running (pg_isready command)
• Check if firewall allows connection
• Confirm host and port configuration is correct

Issue 2: Authentication failed
Symptom: authentication failed
Solution:

• Check if username and password are correct
• Confirm PostgreSQL’s pg_hba.conf allows this user to connect
• Try manual connection with psql command-line tool to verify credentials

Issue 3: Insufficient permissions
Symptom: permission denied for table xxx
Solution:

• This might be a good thing, showing read-only permissions are working
• If you really need to query this table, execute the GRANT command above with admin account

Case Study 3 - API Call Integration

Application Scenario: Let AI Call External Services

Databases solve internal data queries, but sometimes you need data from external APIs. For example:

• Check GitHub repository star count, issue list
• Call company internal microservice APIs
• Get weather, exchange rates, and other real-time data

With MCP, AI can also help you call these interfaces.

Configure HTTP-Type MCP Server

API calls are different from databases—you don’t need to install an MCP Server package, just configure the HTTP type directly.

Using GitHub API as an example, configure .cursor/mcp.json:

{
  "mcpServers": {
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Accept": "application/vnd.github.v3+json",
        "User-Agent": "Cursor-MCP-Client"
      }
    }
  }
}

If the API requires authentication (like GitHub private repositories), add a token:

{
  "mcpServers": {
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Accept": "application/vnd.github.v3+json",
        "Authorization": "Bearer ${GITHUB_TOKEN}",
        "User-Agent": "Cursor-MCP-Client"
      }
    }
  }
}

Similarly, put the token in the .env file:

GITHUB_TOKEN=ghp_your_personal_access_token_here

How to get GitHub Token:

1. Open GitHub → Settings → Developer settings
2. Personal access tokens → Tokens (classic)
3. Generate new token → Check required permissions (repo, user, etc.)
4. Copy token (only shown once, remember to save)

Practical Demo

Once configured, you can directly have AI call APIs:

Query Repository Info

You: Check the star count of facebook/react repository
AI: [Calls GET /repos/facebook/react]
React repository currently has 218,345 stars, 79,234 forks

Get Latest Issues

You: Check recent issues for facebook/react
AI: [Calls GET /repos/facebook/react/issues?state=open&per_page=5]
Recent 5 issues:
1. [Bug] useEffect executes twice in strict mode
2. [Feature] Support new Suspense API
3. [Question] How to optimize large list rendering
...

Analyze Commit Frequency

You: How many commits did facebook/react have in the past week?
AI: [Calls GET /repos/facebook/react/commits?since=...]
43 commits in the past 7 days, main contributors are...

Configure Custom API

Company internal APIs can be configured the same way. Assuming you have an internal user service:

{
  "mcpServers": {
    "user-service": {
      "url": "https://api.yourcompany.com/user-service",
      "headers": {
        "Authorization": "Bearer ${INTERNAL_API_KEY}",
        "Content-Type": "application/json"
      }
    }
  }
}

Then you can ask AI:

You: Check order history for user ID 12345
AI: [Calls internal API] User 12345 placed 8 orders in the past 30 days, total spending 3,200 yuan

Precautions

API Rate Limiting
Many APIs have rate limits. GitHub’s free tier allows only 60 calls per hour. If AI calls frantically, it’s easy to hit the limit.

Solutions:

• Use authentication token (GitHub authenticated limit increases to 5000 calls/hour)
• Tell AI “minimize API calls, reuse results when possible”

Security Risks
Giving AI permission to call APIs means giving it the ability to operate external services. Must:

• Use read-only tokens (don’t give write permissions)
• Regularly rotate tokens
• Monitor API call logs

Advanced Tips and Best Practices

Using Multiple MCP Servers Together

In one project, you can configure multiple MCP Servers simultaneously. AI will automatically select the appropriate tool.

For example, my configuration:

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "D:/projects/myapp/data.db"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "--stdio"],
      "env": {
        "POSTGRES_HOST": "${POSTGRES_HOST}",
        "POSTGRES_PORT": "${POSTGRES_PORT}",
        "POSTGRES_DATABASE": "${POSTGRES_DATABASE}",
        "POSTGRES_USER": "${POSTGRES_USER}",
        "POSTGRES_PASSWORD": "${POSTGRES_PASSWORD}"
      }
    },
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}",
        "Accept": "application/vnd.github.v3+json"
      }
    }
  }
}

With this configuration, I can ask AI:

Vultr - High-performance NVMe VPS with 32 global locations, one-click Docker deploy

View Pricing →Ad

You: Check how many users are in the local SQLite database, then check our repository stars on GitHub
AI: [Automatically selects sqlite MCP] There are 245 local users
    [Automatically selects github-api MCP] Repository has 1.2k stars

AI will judge which tool to use based on the question content. Pretty smart.

Project-Level vs Global Configuration

Two configuration methods, different applicable scenarios:

Project-level configuration (.cursor/mcp.json):

• Suitable for project-specific databases, APIs
• Advantages: Different projects don’t interfere, configuration can be committed to Git (remember to exclude sensitive info)
• Disadvantages: Need to configure for each project

Global configuration (~/.cursor/mcp.json):

• Suitable for universal tools (file system, general APIs, etc.)
• Advantages: Configure once, use everywhere
• Disadvantages: Easy to get messy, and config file isn’t in project, inconvenient for team collaboration

My recommendation:

• Databases, project-specific APIs → Project-level configuration
• GitHub, weather and other general APIs → Global configuration
• After development, organize project-level config into documentation for team to copy

Performance Optimization

MCP executes real queries or API requests each time, which can be slow if called frequently. A few optimization tips:

1. Guide AI to cache results

You: Check the user list (remember this result, will use it later)
AI: [Queries and remembers] There are 245 users...

You: Among those 245 users, how many are VIP?
AI: [No need to query again, directly analyzes based on previous results]

2. Limit query complexity
Don’t let AI write overly complex queries. If AI generates a 10-layer nested SQL, stop it immediately and manually optimize.

3. Use database indexes
No matter how smart AI queries are, they’re still limited by database performance. Add indexes where needed.

Debugging Tips

When encountering problems, these methods can help you quickly locate issues:

1. Check MCP Logs
Cursor’s “Output” panel (View → Output), select “MCP” channel to see:

• MCP Server startup logs
• Parameters and return values for each tool call
• Error stack traces

2. Test MCP Configuration
After writing configuration, test with simple questions first:

You: Test database connection, tell me what tables there are

If this doesn’t work, there’s a configuration problem.

3. Manual Execution Verification
If AI says query failed, you can execute it manually to see if it’s AI-generated SQL that’s wrong, or permissions/connection issues.

Common Error Code Meanings

• ENOENT: File or path doesn’t exist (check path)
• ECONNREFUSED: Connection refused (database not started or wrong port)
• EACCES: Insufficient permissions (file permissions or database permissions)
• ERR_MODULE_NOT_FOUND: MCP Server package not installed (check npx command)
• ETIMEDOUT: Timeout (network issue or query too slow)

Conclusion

Honestly, after configuring MCP, the way I write code has really changed.

Before, checking data meant jumping between three windows, constantly interrupting my train of thought. Now I just ask a question in Cursor, AI returns results instantly, and my thinking stays on the code logic.

This article is over 3000 words, but the core is three things:

1. Understand the concept: MCP gives AI tools, letting it do work instead of just giving advice
2. Follow the configuration: Practice with SQLite, use PostgreSQL for production, extend capabilities with API
3. Prioritize security: Read-only permissions, environment variables, don’t touch production primary database

Take 15 minutes today to configure a SQLite MCP and try it. You’ll find the efficiency boost isn’t 10% or 20%, but a completely different way of working.

One last thing: MCP is still quite new, officials are constantly iterating, and the community is rapidly contributing new Servers. I have a curated list of MCP Servers on GitHub, check it out when you have time—you might find tools that fit your needs.

If you have questions, see you in the comments. I’ll reply.

13 min read · Published on: Jan 17, 2026 · Modified on: Mar 3, 2026

Easton

Technology