Skip to main content
Glama
Sidrahhh

Company Data MCP Server

by Sidrahhh
OverviewSchemaRelated ServersScoreDiscussions
Python
Remote

Company Data MCP Demo

A detailed end-to-end Model Context Protocol (MCP) demo that connects a LangChain/OpenAI chatbot to PostgreSQL, MongoDB Atlas, and local flat files through one read-only MCP server.

The project currently demonstrates:

  • PostgreSQL as a structured relational source

  • MongoDB Atlas as an application-log/document source

  • Flat files as documented operational guidance

  • MCP tools exposed over Streamable HTTP

  • MCP Inspector for independent tool testing

  • LangChain as the MCP client/agent layer

  • OpenAI as the reasoning/model layer

  • Terminal logging of tool selection and tool results

The next planned connector is GitHub/repository access.

1. Architecture

User
  |
  v
chatb.py
LangChain Agent + OpenAI
  |
  v
MCP Client
  |
  | Streamable HTTP
  v
MCP Server
  |
  +----------------------+----------------------+----------------------+
  |                      |                      |
  v                      v                      v
PostgreSQL           MongoDB Atlas          Flat Files

Current MCP tools:

PostgreSQL
----------
list_sql_tables
describe_sql_table
query_sql_table

MongoDB
-------
list_mongo_collections
find_mongo_documents

Flat files
----------
list_data_files
read_data_file
search_data_files

These tools are generic but constrained. The model does not receive arbitrary SQL execution, arbitrary Mongo commands, or unrestricted filesystem access.

Related MCP server: Sprinklr MCP Server

2. Project structure

company-data-mcp-demo/
|
|-- .env
|-- .env.example
|-- .gitignore
|-- requirements.txt
|-- README.md
|-- chatb.py
|
|-- data/
|   |-- error_codes.csv
|   |-- notes.txt
|   `-- runbook.json
|
`-- mcp_server/
    |-- __init__.py
    |-- server.py
    |
    `-- connectors/
        |-- __init__.py
        |-- sql_connector.py
        |-- mongo_connector.py
        `-- file_connector.py

The two __init__.py files may remain empty.

3. Prerequisites

Install:

  • Python

  • PostgreSQL

  • Node.js

  • MongoDB Atlas account

  • OpenAI API key

  • VS Code or another editor

Check:

python --version
node --version
npm --version
psql --version

The current MCP Inspector v2 requires a recent Node.js 22 release. Its current release notes require Node.js 22.19.0 or newer.

4. Create and activate the Python environment

Create:

python -m venv .venv

Windows CMD:

.venv\Scripts\activate

PowerShell:

.venv\Scripts\Activate.ps1

Example prompt:

(.venv) D:\ayna project>

5. requirements.txt

Use the pinned environment that has been tested with this project:

# MCP
mcp==1.29.0
langchain-mcp-adapters==0.3.2

# LLM / Agent
langchain==1.3.14
langchain-openai==1.4.0
openai==2.47.0

# Environment variables
python-dotenv==1.2.1

# PostgreSQL
psycopg[binary]==3.3.4

# MongoDB Atlas
pymongo==3.12.0
dnspython>=1.16.0

Install:

python -m pip install -r requirements.txt

Validate:

python -m pip check

Expected:

No broken requirements found.

MCP version note

This project currently pins:

mcp==1.29.0

because:

langchain-mcp-adapters==0.3.2

requires MCP below 2.

Therefore server.py uses:

from mcp.server.fastmcp import FastMCP

and starts with:

mcp.run(
    transport="streamable-http"
)

Do not add:

stateless_http=True
json_response=True

to this pinned MCP 1.x server.

6. Environment variables

Create .env in the project root:

OPENAI_API_KEY=your_openai_api_key

# PostgreSQL
DB_HOST=localhost
DB_PORT=5432
DB_NAME=company_demo
DB_USER=mcp_user
DB_PASSWORD=your_postgresql_password

# MongoDB Atlas
MONGODB_USER=mongo_mcp_user
MONGODB_PASSWORD=your_mongodb_password
MONGODB_HOST=cluster0.example.mongodb.net
MONGODB_DB=company_demo

Create .env.example with placeholders only:

OPENAI_API_KEY=your_openai_api_key_here

DB_HOST=localhost
DB_PORT=5432
DB_NAME=company_demo
DB_USER=mcp_user
DB_PASSWORD=your_postgres_password_here

MONGODB_USER=mongo_mcp_user
MONGODB_PASSWORD=your_mongodb_password_here
MONGODB_HOST=cluster0.example.mongodb.net
MONGODB_DB=company_demo

Recommended .gitignore:

.env
.venv/
venv/
__pycache__/
*.pyc
*.pyo
*.pyd
.vscode/
.DS_Store
Thumbs.db

Never commit real secrets.

PostgreSQL setup

7. Start PostgreSQL and connect

Make sure PostgreSQL is running.

Connect as administrator:

psql -U postgres

8. Create the database

CREATE DATABASE company_demo;

Connect:

\c company_demo

9. Create the employees table

CREATE TABLE employees (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    department VARCHAR(100),
    role VARCHAR(100),
    email VARCHAR(255)
);

10. Create the payments table

CREATE TABLE payments (
    id SERIAL PRIMARY KEY,
    employee_id INTEGER REFERENCES employees(id),
    payment_id VARCHAR(100) UNIQUE NOT NULL,
    amount NUMERIC(10,2),
    status VARCHAR(50),
    error_code VARCHAR(50)
);

11. Insert example employee data

INSERT INTO employees (
    name,
    department,
    role,
    email
)
VALUES
(
    'Alice',
    'Engineering',
    'Developer',
    'alice@example.com'
),
(
    'Bob',
    'Finance',
    'Analyst',
    'bob@example.com'
),
(
    'Charlie',
    'Security',
    'Security Engineer',
    'charlie@example.com'
);

Verify:

SELECT * FROM employees;

Important expected records:

1 | Alice   | Engineering | Developer
2 | Bob     | Finance     | Analyst
3 | Charlie | Security    | Security Engineer

12. Insert example payment data

INSERT INTO payments (
    employee_id,
    payment_id,
    amount,
    status,
    error_code
)
VALUES
(
    1,
    'PAY-001',
    5000.00,
    'FAILED',
    'E109'
),
(
    2,
    'PAY-002',
    2500.00,
    'SUCCESS',
    NULL
),
(
    1,
    'PAY-003',
    1200.00,
    'SUCCESS',
    NULL
);

Verify:

SELECT * FROM payments;

Important data:

Alice -> PAY-001 -> 5000.00 -> FAILED  -> E109
Bob   -> PAY-002 -> 2500.00 -> SUCCESS -> NULL
Alice -> PAY-003 -> 1200.00 -> SUCCESS -> NULL

13. Create a dedicated read-only PostgreSQL MCP user

Do not connect the MCP server using the postgres administrator account.

Create:

CREATE USER mcp_user WITH PASSWORD 'choose_a_strong_password';

Allow database connection:

GRANT CONNECT ON DATABASE company_demo TO mcp_user;

Allow schema usage:

GRANT USAGE ON SCHEMA public TO mcp_user;

Allow reads:

GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_user;

Ensure future tables also receive SELECT access:

ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT ON TABLES TO mcp_user;

14. Verify PostgreSQL read-only behavior

Exit:

\q

Connect as MCP user:

psql -U mcp_user -d company_demo -h localhost

Reading should work:

SELECT * FROM employees;

A write should fail:

DELETE FROM employees WHERE id = 1;

The failed DELETE is expected and proves that the application credential is read-only.

MongoDB Atlas setup

15. Atlas overview

MongoDB Atlas is the managed cloud MongoDB deployment used in this demo.

When using Atlas:

  • local mongod is not the database server used by the app

  • mongosh can still be used as a client

  • PyMongo connects to Atlas over the network

16. Create/select an Atlas deployment

  1. Sign in to MongoDB Atlas.

  2. Create or choose a project.

  3. Create a cluster/deployment.

  4. Wait until it is ready.

Atlas UI wording can change slightly over time.

17. Configure Network Access

Open the project's security/network access area.

Add your current public IP address to the IP access list.

For production, avoid unnecessarily broad rules such as:

0.0.0.0/0

unless the deployment has intentionally been designed for that exposure.

18. Create the MongoDB database and collection

In Atlas open:

Database
  ->
Data Explorer

Select the cluster and choose:

Create Database

Use:

Database:
company_demo

Collection:
application_logs

The structure becomes:

Atlas Cluster
|
`-- company_demo
    |
    `-- application_logs

MongoDB terminology:

PostgreSQL       MongoDB
----------       -------
Database         Database
Table            Collection
Row              Document
Column           Field

19. Add sample MongoDB documents

Open:

company_demo
  ->
application_logs

Use the Atlas document insert UI.

PAY-001

{
  "payment_id": "PAY-001",
  "service": "payment-service",
  "error_code": "E109",
  "message": "Gateway timeout while contacting payment provider",
  "retry_count": 0,
  "severity": "ERROR"
}

PAY-002

{
  "payment_id": "PAY-002",
  "service": "payment-service",
  "message": "Payment completed successfully",
  "retry_count": 0,
  "severity": "INFO"
}

PAY-003

{
  "payment_id": "PAY-003",
  "service": "payment-service",
  "message": "Payment completed successfully",
  "retry_count": 0,
  "severity": "INFO"
}

Correlation:

PostgreSQL:
PAY-001 -> FAILED -> E109

MongoDB:
PAY-001 -> Gateway timeout -> retry_count 0

20. Create a separate read-only MongoDB user

Do not use the initial setup/admin database user for the MCP server.

In Atlas, open the database access page and add another database user.

Create:

Username:
mongo_mcp_user

Use password/SCRAM authentication.

Assign:

Role:
read

Database:
company_demo

The intended permission model is:

mongo_mcp_user
    |
    | read only
    v
company_demo

Do not give the MCP account broad roles such as:

atlasAdmin
readWriteAnyDatabase

Remember:

Atlas UI users != MongoDB database users

The database user is what PyMongo uses.

21. Test the MongoDB read-only user

Connect with mongosh:

mongosh "mongodb+srv://YOUR_CLUSTER_HOST/" --username mongo_mcp_user

Enter the password.

Use:

use company_demo

Read:

db.application_logs.find()

This should succeed.

Test write protection:

db.application_logs.insertOne({
    test: "should fail"
})

It should fail with an authorization error.

22. MongoDB special-character passwords

If the MongoDB username/password contains reserved URI characters such as:

@
:
/
?
#
%
&
+

they must be URL-encoded before being inserted into the connection URI.

The connector handles this with:

from urllib.parse import quote_plus

and stores the username/password separately in .env.

23. Test the Mongo connector directly

A direct connector query for PAY-001 should return approximately:

[
    {
        'payment_id': 'PAY-001',
        'service': 'payment-service',
        'error_code': 'E109',
        'message': 'Gateway timeout while contacting payment provider',
        'retry_count': 0,
        'severity': 'ERROR'
    }
]

This proves:

Python
  ->
PyMongo
  ->
Atlas
  ->
company_demo
  ->
application_logs

before MCP is involved.

Flat-file setup

24. Create the approved data directory

Create:

data/

in the project root:

company-data-mcp-demo/
|
`-- data/
    |-- error_codes.csv
    |-- notes.txt
    `-- runbook.json

The connector is sandboxed to this directory.

It should reject paths attempting to leave it, such as:

../../.env

25. Add error_codes.csv

Create:

data/error_codes.csv

Contents:

error_code,meaning,recommended_action
E109,Gateway timeout,Retry up to 3 times with exponential backoff
E201,Invalid account details,Verify account information before retrying
E305,Provider unavailable,Wait and retry later

This provides the documented remediation guidance for the SQL/Mongo example.

Full relationship:

PostgreSQL
PAY-001 -> FAILED -> E109

MongoDB
PAY-001 -> Gateway timeout -> retry_count 0

CSV
E109 -> Retry up to 3 times with exponential backoff

26. Optional notes.txt

Example:

Payment failures must be investigated using transaction records,
application logs, and documented error handling guidance.

27. Optional runbook.json

Example:

{
  "payment_service": {
    "owner": "Payments Team",
    "critical_severity": "ERROR"
  }
}

Only put real intended demo/documentation claims into these files, because the chatbot may treat their contents as company guidance.

28. Flat-file types supported by the current connector

The connector permits:

.csv
.json
.txt
.log
.md
.yaml
.yml

These are handled as text-oriented files.

Generic tools:

list_data_files
read_data_file
search_data_files

Example:

search_data_files("E109")

can locate the matching row in error_codes.csv.

MCP server and tools

29. Why the tools are generic but constrained

The project avoids ultra-specific tools such as:

get_alice
lookup_E109
find_failed_alice_payment

Instead it exposes:

list_sql_tables
describe_sql_table
query_sql_table

list_mongo_collections
find_mongo_documents

list_data_files
read_data_file
search_data_files

The agent determines the correct source and query.

However, access is still constrained through:

  • PostgreSQL read-only credentials

  • SQL table allowlists

  • SQL column allowlists

  • MongoDB read-only credentials

  • MongoDB collection allowlists

  • MongoDB field allowlists

  • query result limits

  • approved filesystem directory

  • approved file extensions

The server intentionally does not expose:

run_any_sql
execute_any_mongo_command
read_any_path

Starting and testing the MCP server

30. Start the server

Terminal 1:

.venv\Scripts\activate
python -m mcp_server.server

The MCP endpoint is:

http://localhost:8000/mcp

Keep this terminal open.

MCP Inspector

31. What MCP Inspector is

MCP Inspector is a development/testing client for MCP servers.

It allows you to inspect:

  • connection status

  • tools

  • tool schemas

  • arguments

  • responses

  • errors

A useful mental model is:

MCP Inspector = Postman for MCP

32. Start MCP Inspector

Terminal 2:

npx @modelcontextprotocol/inspector@latest

The current Inspector package includes a browser UI.

Use the local URL printed by Inspector if it does not open automatically.

33. Connect Inspector

Select:

Transport:
Streamable HTTP

Use:

http://localhost:8000/mcp

Connect.

Expected tool list:

list_sql_tables
describe_sql_table
query_sql_table

list_mongo_collections
find_mongo_documents

list_data_files
read_data_file
search_data_files

34. Inspector PostgreSQL tests

List tables

Tool:

list_sql_tables

Expected:

{
  "tables": [
    "employees",
    "payments"
  ]
}

Describe employees

Tool:

describe_sql_table

Arguments:

{
  "table_name": "employees"
}

Expected columns include:

id
name
department
role
email

Query Alice

Tool:

query_sql_table

Arguments:

{
  "table_name": "employees",
  "filter_column": "name",
  "filter_value": "Alice",
  "limit": 20
}

Expected result:

{
  "table": "employees",
  "rows": [
    {
      "id": 1,
      "name": "Alice",
      "department": "Engineering",
      "role": "Developer",
      "email": "alice@example.com"
    }
  ]
}

35. Inspector MongoDB tests

List collections

Tool:

list_mongo_collections

Expected:

{
  "collections": [
    "application_logs"
  ]
}

Find PAY-001

Tool:

find_mongo_documents

Arguments:

{
  "collection_name": "application_logs",
  "field": "payment_id",
  "value": "PAY-001",
  "limit": 20
}

Expected result contains:

{
  "payment_id": "PAY-001",
  "service": "payment-service",
  "error_code": "E109",
  "message": "Gateway timeout while contacting payment provider",
  "retry_count": 0,
  "severity": "ERROR"
}

36. Inspector flat-file tests

List files

Tool:

list_data_files

Expected to include:

error_codes.csv

Search E109

Tool:

search_data_files

Arguments:

{
  "query": "E109",
  "max_results": 50
}

Expected match:

E109,Gateway timeout,Retry up to 3 times with exponential backoff

Read the CSV

Tool:

read_data_file

Arguments:

{
  "path": "error_codes.csv"
}

37. Recommended testing order

Use:

Connector test
      |
      v
MCP Inspector
      |
      v
Chatbot

Why:

  • connector fails -> source/credential/query issue

  • connector works but Inspector fails -> MCP server/tool issue

  • Inspector works but chatbot fails -> MCP client/agent issue

Chatbot

38. Start the chatbot

Keep the MCP server running.

Terminal 3:

.venv\Scripts\activate
python chatb.py

Expected startup tool discovery:

AVAILABLE MCP TOOLS

- list_sql_tables
- describe_sql_table
- query_sql_table
- list_mongo_collections
- find_mongo_documents
- list_data_files
- read_data_file
- search_data_files

39. Agent/tool trace logging

The chatbot prints observable agent actions:

[AGENT SELECTED TOOL]
Tool: query_sql_table
Arguments: {...}

[TOOL RESULT]
Tool: query_sql_table
Result: ...

This lets you demonstrate the full source-selection trajectory.

Example:

Question
   |
   v
SQL tool
   |
   v
SQL result
   |
   v
Mongo tool
   |
   v
Mongo result
   |
   v
File tool
   |
   v
File result
   |
   v
Final answer

This is tool execution visibility, not the model's private hidden chain-of-thought.

Example questions and expected answers

40. Main demo question

Ask:

Why did Alice's payment fail and what is the documented recommended action?

A good tool flow:

list_sql_tables
       |
       v
query_sql_table(employees, name=Alice)
       |
       v
Alice -> id 1
       |
       v
query_sql_table(payments, employee_id=1)
       |
       v
PAY-001 -> FAILED -> E109
       |
       v
find_mongo_documents(application_logs, payment_id=PAY-001)
       |
       v
Gateway timeout -> retry_count 0
       |
       v
search_data_files(E109)
       |
       v
Retry up to 3 times with exponential backoff

Expected grounded answer:

Alice's payment PAY-001 for 5000.00 failed with error code E109.

The application log shows that the payment service encountered a
gateway timeout while contacting the payment provider.

The log records retry_count = 0.

According to the documented E109 guidance in error_codes.csv,
the recommended action is to retry up to 3 times with exponential
backoff.

41. Question: Which employees are in the database?

Ask:

Which employees are available in the database?

Expected behavior:

list_sql_tables
query_sql_table(employees)

Expected answer includes:

Alice
Bob
Charlie

42. Question: What payments belong to Alice?

Ask:

What payments belong to Alice?

Expected flow:

query employees for Alice
        ->
employee id 1
        ->
query payments where employee_id = 1

Expected answer:

PAY-001 - 5000.00 - FAILED - E109
PAY-003 - 1200.00 - SUCCESS

43. Question: What happened to PAY-001?

Ask:

What happened to PAY-001?

Expected flow:

query_sql_table(payments, payment_id=PAY-001)
find_mongo_documents(application_logs, payment_id=PAY-001)

Expected answer:

PAY-001 failed with error code E109.
The application log records a gateway timeout while contacting
the payment provider.

44. Question: What does E109 mean?

Ask:

What does E109 mean and what should be done?

Expected:

search_data_files("E109")

Expected answer:

E109 means Gateway timeout.
The documented recommended action is to retry up to 3 times
with exponential backoff.

45. Question: Show PAY-002 application logs

Ask:

Show me the application logs for PAY-002.

Expected:

find_mongo_documents(
    collection_name="application_logs",
    field="payment_id",
    value="PAY-002"
)

Expected answer:

PAY-002 completed successfully.
The application log has severity INFO and retry_count 0.

46. Question: Which failures have documented remediation?

Ask:

Which failed payments have documented remediation guidance?

A capable agent may:

  1. inspect payments

  2. find failed payments/error codes

  3. search flat files for those codes

  4. combine the information

For the sample dataset, the expected match is:

PAY-001 -> E109 -> Retry up to 3 times with exponential backoff

Grounding rules

47. Claims the chatbot can make

It can say:

PAY-001 failed.

because PostgreSQL contains that fact.

It can say:

The application logged a gateway timeout.

because MongoDB contains that fact.

It can say:

The documented recommendation is retry up to three times
with exponential backoff.

because the CSV contains that guidance.

48. Claims it should not make without evidence/tools

It should not claim:

"The external provider definitely had an outage."

The log only says a gateway timeout occurred.

It should not claim:

"I retried the payment."

No write/retry tool exists.

It should not claim:

"I opened a ticket."

No ticketing tool exists.

It should not invent escalation procedures that are not present in a connected file/database/repository.

Troubleshooting

49. cannot import name MCPServer

With:

mcp==1.29.0

use:

from mcp.server.fastmcp import FastMCP

not:

from mcp.server import MCPServer

50. FastMCP.run() unexpected stateless_http

Use:

mcp.run(
    transport="streamable-http"
)

Do not pass the MCP v2-only options to this pinned v1 server.

51. MongoDB InvalidURI

If you see an error about escaping the username/password according to RFC 3986, encode credentials using:

from urllib.parse import quote_plus

Do not manually paste an unescaped special-character password into the URI.

52. MongoDB authentication/network failures

Check:

  • MONGODB_USER

  • MONGODB_PASSWORD

  • MONGODB_HOST

  • Atlas IP access list

  • database user role

  • target database name

53. PostgreSQL permission errors

Ensure:

GRANT CONNECT ON DATABASE company_demo TO mcp_user;
GRANT USAGE ON SCHEMA public TO mcp_user;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_user;

54. Inspector cannot connect

Verify Terminal 1 is still running:

python -m mcp_server.server

Use:

Transport: Streamable HTTP
URL: http://localhost:8000/mcp

55. Pydantic lifespan warning

You may see an IncompleteFieldDefinitionWarning related to the MCP lifespan field.

If:

python -m pip check

returns:

No broken requirements found.

and the server/Inspector/tools work, this warning is non-blocking for this demo.

Do not modify your own code with arbitrary model_rebuild() calls solely to hide a library warning.

Running the complete demo

56. Terminal layout

Terminal 1 - MCP server

.venv\Scripts\activate
python -m mcp_server.server

Terminal 2 - MCP Inspector when testing

npx @modelcontextprotocol/inspector@latest

Connect to:

http://localhost:8000/mcp

using Streamable HTTP.

Terminal 3 - chatbot

.venv\Scripts\activate
python chatb.py

Security summary

57. PostgreSQL

Dedicated account:
mcp_user

Database privileges:
read only

The connector also restricts allowed tables/columns.

58. MongoDB

Dedicated account:
mongo_mcp_user

Database role:
read on company_demo

The connector also restricts allowed collections/fields.

59. Flat files

Only the project's approved:

data/

directory is accessible.

The connector resolves and validates paths to prevent directory traversal.

60. Secrets

Keep secrets only in:

.env

Never commit .env.

If a password or API key is accidentally exposed, rotate it.

Current project status

OpenAI chatbot              DONE
LangChain agent             DONE
MCP server                  DONE
MCP Inspector               DONE
PostgreSQL                  DONE
MongoDB Atlas               DONE
Flat files                  DONE
Agent/tool trace logging    DONE
GitHub connector            NEXT

Next phase: GitHub/repository connector

Planned generic GitHub tools:

list_repository_files
read_repository_file
search_repository

Final intended four-source question:

Investigate Alice's failed payment,
explain the root cause,
tell me the documented recommended action,
and check whether our code implements it.

Expected final flow:

PostgreSQL
   |
   | PAY-001 / FAILED / E109
   v
MongoDB
   |
   | Gateway timeout / retry_count 0
   v
Flat files
   |
   | Retry up to 3 times with exponential backoff
   v
GitHub repository
   |
   | Inspect implementation
   v
Final grounded answer

Official references

MongoDB Atlas database users:

https://www.mongodb.com/docs/atlas/security-add-mongodb-users/

MongoDB Atlas databases/Data Explorer:

https://www.mongodb.com/docs/atlas/atlas-ui/databases/

PostgreSQL documentation:

https://www.postgresql.org/docs/current/

MCP Inspector:

https://github.com/modelcontextprotocol/inspector

MCP Python SDK:

https://github.com/modelcontextprotocol/python-sdk

This server cannot be installed

F
license - not found
-
quality - not tested
C
maintenance

How are these scores calculated?

Maintenance

–Maintainers
–Response time
–Release cycle
–Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

  • Database Lookup Protocol (DLP)

    kalyangupta12
    A
    license
    -
    quality
    B
    maintenance
    Provides AI assistants with read-only access to inspect database schemas, preview data, and run safe queries across PostgreSQL, MySQL, MongoDB, and SQL Server. It enables AI tools to understand database structures and relationships automatically to generate more accurate code.
    7
    7
    MIT

  • Sprinklr MCP Server

    daiict218
    A
    license
    -
    quality
    C
    maintenance
    Enables AI assistants read-only access to Sprinklr data via MCP, allowing querying reports, searching cases, and calling Sprinklr API endpoints.
    7
    ISC

  • aifordatabase-mcp

    dann26parr69
    A
    license
    A
    quality
    C
    maintenance
    Give your AI agent safe, plain-English access to any database via MCP. Ask questions in natural language, get SQL queries and results, run read-only queries, and set up scheduled alerts.
    9
    60
    MIT

  • Database Assistant MCP Server

    vinycoolguy2015
    F
    license
    A
    quality
    C
    maintenance
    Enables read-only exploration and querying of PostgreSQL or MySQL databases via MCP, with schema discovery, safe SQL validation, natural language to SQL conversion, and CSV export.
    11
    1

View all related MCP servers

Related MCP Connectors

  • nlqdb — analytical memory for AI agents

    Analytical memory for AI agents: a real Postgres queried in plain English over MCP. One command.

  • Presso

    Connect e-commerce and marketing data to AI assistants via MCP.

  • ko-mcp

    Real SEC, 13F, insider, congress & macro data your AI agent can cite. Hosted MCP, 24 tools.

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Sidrahhh/mcp-demo'

If you have feedback or need assistance with the MCP directory API, please join our Discord server