Mongodb MCP Setup
MongoDBOfficialPublished by MongoDB
- Skill
- Workflow
- Data and AI
- Apache-2.0
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a structured, interactive guide for setting up the MongoDB MCP server. It helps users choose between three authentication methods—Connection String, Service Account Credentials, or local Docker-based development—and provides specific configuration steps based on whether the user is running a shell-based agent or the Codex desktop application. The workflow emphasizes security by instructing users to manage credentials directly in their environment or configuration files rather than sharing them with the agent.
What it does
- Detects the user's agentic client type to provide tailored configuration instructions.
- Checks existing environment variables or configuration files for current setup status.
- Guides users through setting up MongoDB Atlas Service Accounts with proper API Access List permissions.
- Provides instructions for configuring read-only versus read-write access modes.
- Offers secure methods for storing credentials in shell profiles or configuration files.
- Includes troubleshooting steps for common environment and connectivity issues.
When to use it
- When you have installed the MongoDB MCP server but have not yet configured the required environment variables.
- When you need to connect to MongoDB or Atlas and are unsure how to manage the necessary credentials.
- When you want to switch between different authentication methods like connection strings or service accounts.
- When you need to enable read-only access for production safety or compliance.
Advantages
- Ensures secure credential handling by keeping sensitive data out of the agent's direct input.
- Provides clear, step-by-step paths for different user environments (shell vs. Codex).
- Reduces setup errors by verifying configurations and providing specific snippets.
- Includes critical security warnings regarding API Access Lists and plaintext storage.
Usage examples
- “How do I set up the MongoDB MCP server for my Atlas cluster?”
- The agent will initiate the setup workflow, detect your client type, and guide you through selecting the appropriate authentication method (Connection String or Service Account).
- “I need to configure my MongoDB credentials for the Codex app.”
- The agent will provide specific instructions for updating your ~/.codex/config.toml file with the required environment variables.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/mongodb/mongodb-mcp-setup/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip mongodb-mcp-setup.zip -d .agents/skills
Documentation by MongoDB
MongoDB MCP Server Setup
This skill guides users through configuring the MongoDB MCP server for use with an agentic client.
Overview
The MongoDB MCP server requires authentication. Users have three options:
Connection String (Option A): Direct connection to a specific cluster
Quick setup for single cluster
Requires
MDB_MCP_CONNECTION_STRINGenvironment variable
Service Account Credentials (Option B): MongoDB Atlas Admin API access
Recommended for Atlas users - simplifies authentication and data access
Access to Atlas Admin API and dynamic cluster connection via
atlas-connect-clusterNo manual DB user credential management
Requires
MDB_MCP_API_CLIENT_IDandMDB_MCP_API_CLIENT_SECRETenvironment variables
Atlas Local (Option C): Local development with Docker
Best for local testing - zero configuration required
Runs Atlas locally in Docker, requires Docker installed
No credentials or cloud cluster access
This is an interactive step-by-step guide. The agent detects the user's environment and provides tailored instructions, but never asks for or handles credentials — users add those directly to their shell profile or agentic client config in Step 5. Make this clear to the user whenever credentials come up in Steps 3a and 3b.
Step 0: Detect Client
Before anything else, determine which agentic client the user is running. This controls how credentials are configured in Step 1 and Step 5.
Run:
env | grep "^CODEX_"If no
CODEX_*variables are present → the user is running a shell-based client (Claude, Cursor, Gemini CLI, Copilot CLI, etc.). Credentials are configured via shell profile environment variables.If any
CODEX_*variables are present → the user is running Codex. Credentials are stored in~/.codex/config.toml(macOS/Linux) or%USERPROFILE%\.codex\config.toml(Windows), not in shell environment variables. The desktop app does not inherit shell env vars when launched from Finder, Launchpad, or the Windows Start menu.
Carry this client type (Codex vs. shell-based) forward through every subsequent step.
Step 1: Check Existing Configuration
Check whether credentials are already configured.
For shell-based clients — check the current environment:
env | grep "^MDB_MCP" | sed '/^MDB_MCP_READ_ONLY=/!s/=.*/=[set]/'For Codex — search ~/.codex/config.toml (macOS/Linux) or %USERPROFILE%\.codex\config.toml (Windows):
grep -E 'MDB_MCP_(CONNECTION_STRING|API_CLIENT_ID|API_CLIENT_SECRET|READ_ONLY)' ~/.codex/config.toml 2>/dev/null | sed '/MDB_MCP_READ_ONLY/!s/[[:space:]]*=[[:space:]].*/ = "[set]"/'Interpretation (both):
If
MDB_MCP_CONNECTION_STRINGappears → connection string auth is configuredIf both
MDB_MCP_API_CLIENT_IDandMDB_MCP_API_CLIENT_SECRETappear → service account auth is configured. If only one is present, treat it as incomplete.If
MDB_MCP_READ_ONLYappears → read-only mode is enabled
Partial Configuration Handling:
User wants to add read-only to existing setup (has auth, no read-only flag) → skip to Step 4
User wants to switch authentication methods → explain they should remove the old credentials first (from
config.tomlfor Codex, from their shell profile for shell-based clients), then proceed with Steps 2–5User wants to update credentials → skip to Step 5
Important: If the user wants an Atlas Admin API action (managing clusters, creating users, performance advisor) but only has MDB_MCP_CONNECTION_STRING, explain they need service account credentials and offer to walk through setup.
Step 2: Present Configuration Options
If no valid configuration exists, present the options:
Connection String (Option A) — Best for:
Single cluster access
Existing database credentials
Self-hosted MongoDB or no Atlas Admin API needs
Service Account Credentials (Option B) — Best for:
MongoDB Atlas users (recommended)
Multi-cluster switching
Atlas Admin API access (cluster management, user creation, performance monitoring)
Atlas Local (Option C) — Best for:
Local development/testing without cloud setup
Fastest setup with Docker, no credentials required
Ask the user which option they'd like to proceed with.
Step 3a: Connection String Setup
If the user chooses Option A:
3a.1: Explain How to Find the Connection String
Explain where and how to obtain their connection string:
For MongoDB Atlas:
Go to cloud.mongodb.com
Select your cluster → click Connect
Choose Drivers or Shell → copy the connection string
Replace
<username>and<password>with your database user credentials
For self-hosted MongoDB:
The connection string is typically configured by your DBA or in your application config
Format:
mongodb://username:password@host:port/database
Expected formats:
mongodb://username:password@host:port/databasemongodb+srv://username:[email protected]/databasemongodb://host:port(local, no auth)
Proceed to Step 4 (Determine Read-Only Access).
Step 3b: Service Account Setup
If the user chooses Option B:
3b.1: Guide Through Atlas Service Account Creation
Direct the user to create a MongoDB Atlas Service Account:
Full documentation: https://www.mongodb.com/docs/mcp-server/prerequisites/
Walk them through the key steps:
Navigate to MongoDB Atlas — cloud.mongodb.com
Select your organization from the ORGANIZATION section near the top of the page
Go to "Project Identity and Access" on the left sidebar → Applications → Create Service Account
Set Permissions — Grant Organization Member or Project Owner (see docs for exact permission mappings)
Generate Credentials — Create Client ID and Secret
⚠️ The Client Secret is shown only once — save it immediately before leaving the page
Note both values — you'll need Client ID and Client Secret for Step 5
3b.2: API Access List Configuration
⚠️ CRITICAL: The user MUST add their IP address to the service account's API Access List, or all Atlas Admin API operations will fail.
Steps:
On the service account details page, find API Access List
Click Add Access List Entry
Add your current IP address. Use a specific IP or CIDR range whenever possible.
⚠️
0.0.0.0/0allows access from any IP — this is a significant security risk. Only use it as a last resort for temporary testing and remove it immediately afterward. It should never be used in production.
Save changes
This is more secure than global Network Access settings as it only affects API access, not database connections.
Proceed to Step 4 (Determine Read-Only Access).
Step 3c: Atlas Local Setup
If the user chooses Option C:
3c.1: Check Docker Installation
Verify Docker is installed:
docker infoIf not installed, direct them to: https://www.docker.com/get-started
3c.2: Confirm Setup Complete
Atlas Local requires no credentials — the user is ready to go:
Create deployments:
atlas-local-create-deploymentList deployments:
atlas-local-list-deploymentsAll operations work out of the box with Docker
Skip Steps 4 and 5 (no configuration needed) and proceed to Step 6 (Next Steps).
Step 4: Determine Read-Only vs Read-Write Access
Only applies to Options A and B. Skip to Step 6 for Option C.
Ask whether they want read-only or read-write access:
Read-Write (default): Full data access, modifications allowed
Best for: Development, testing, administrative tasks
Read-Only: Data reads only, no modifications
Best for: Production data safety, reporting, compliance
If read-only: include the read-only flag in the credential snippet in Step 5. If read-write: omit it (defaults to read-write).
Proceed to Step 5 (Configure Credentials).
Step 5: Configure Credentials
Do not ask for or handle credentials — provide exact instructions so the user can add them directly.
5.1: Add credentials
For shell-based clients — store credentials in a dedicated ~/.mcp-env file (not directly in the shell profile), then source it from the profile. This keeps credentials out of files that are often group/world readable by default and prevents accidentally committing them to git.
For Codex — add to ~/.codex/config.toml (macOS/Linux) or %USERPROFILE%\.codex\config.toml (Windows).
Show the user the appropriate snippet:
For Connection String (Option A):
Shell-based clients (~/.mcp-env):
export MDB_MCP_CONNECTION_STRING="<paste-your-connection-string-here>"Codex (config.toml):
[mcp_servers.mongodb.env]
MDB_MCP_CONNECTION_STRING = "<paste-your-connection-string-here>"For Service Account (Option B):
Shell-based clients (~/.mcp-env):
export MDB_MCP_API_CLIENT_ID="<paste-your-client-id-here>"
export MDB_MCP_API_CLIENT_SECRET="<paste-your-client-secret-here>"Codex (config.toml):
[mcp_servers.mongodb.env]
MDB_MCP_API_CLIENT_ID = "<paste-your-client-id-here>"
MDB_MCP_API_CLIENT_SECRET = "<paste-your-client-secret-here>"If read-only was chosen (Step 4), also add:
Shell-based: export MDB_MCP_READ_ONLY="true" in ~/.mcp-env.
Codex: MDB_MCP_READ_ONLY = "true" under the same [mcp_servers.mongodb.env] section.
⚠️ Both config.toml and ~/.mcp-env are stored in plaintext. Do not commit them to version control.
5.2: Finalize (shell-based clients only)
Restrict permissions on ~/.mcp-env:
# adjust for windows if needed
chmod 600 ~/.mcp-envAdd source ~/.mcp-env to the shell profile (e.g. ~/.zshrc). Adjust for the detected shell (e.g. for fish: bass source ~/.mcp-env or set -x; for PowerShell: dot-source a .ps1 file instead).
Detect the shell and profile file by running echo $SHELL if needed.
5.3: Verify
Shell-based clients — reload the profile first, then verify:
source ~/.zshrc # adjust to match the profile file
env | grep "^MDB_MCP" | sed '/^MDB_MCP_READ_ONLY=/!s/=.*/=[set]/'Codex:
# adjust path if on Windows
grep -E 'MDB_MCP_(CONNECTION_STRING|API_CLIENT_ID|API_CLIENT_SECRET|READ_ONLY)' ~/.codex/config.toml 2>/dev/null | sed '/MDB_MCP_READ_ONLY/!s/[[:space:]]*=[[:space:]].*/ = "[set]"/'Expected output shows the configured key(s) with values redacted to [set]. If nothing appears, check that credentials were saved and (for shell-based clients) that the profile was reloaded.
Proceed to Step 6 (Next Steps).
Step 6: Next Steps
For Options A & B (Connection String / Service Account):
Restart the agentic client:
Shell-based clients: Fully quit the client, then run
source <profile-file>to load the new variables, and reopen the client from that same terminal session so it inherits the environment.Codex: Fully quit and relaunch the app. No terminal session needed — credentials come from
config.toml.
Verify MCP Server: After restart, test by performing a MongoDB operation.
Using the Tools:
Option A: Direct database access tools available
Option B: Additionally has Atlas Admin API tools and
atlas-connect-clusterImportant (Option B): Ensure your IP is in the service account's API Access List or all API calls will fail
For Option C (Atlas Local):
Ready to use: No restart or configuration needed!
Next steps:
Create deployments:
atlas-local-create-deploymentList deployments:
atlas-local-list-deploymentsUse standard database operations once connected
Troubleshooting
Variables not appearing after
source(shell-based clients): Check the profile file path and confirm the file was savedClient doesn't pick up variables: Ensure full restart (quit + reopen), not just a reload
Codex desktop app not picking up credentials: If launched from Finder, Launchpad, or the Windows Start menu, Codex does not inherit shell environment variables from
.zshrc/.zprofile/PowerShell profiles. Use~/.codex/config.toml(macOS/Linux) or%USERPROFILE%\.codex\config.toml(Windows) instead (see Step 5)Invalid connection string format: Re-check the format; must start with
mongodb://ormongodb+srv://Atlas Admin API errors (Option B): Verify your IP is in the service account's API Access List
Read-only mode not working: Check that
MDB_MCP_READ_ONLYis set — inconfig.tomlunder[mcp_servers.mongodb.env]for Codex, or viaenv | grep ^MDB_MCP_READ_ONLYfor shell-based clientsfish/PowerShell: Syntax differs — use
set -x(fish) or$env:(PowerShell) instead ofexport
Files
- ATTRIBUTION.mdAdded by AutoGineer837 B
- LICENSELicence file added by AutoGineer11.1 KiB
- SKILL.md13.0 KiB
LICENSE
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Needs an MCP server, Needs a command-line tool
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Published by
- MongoDB
- Publisher
- MongoDB (Official)
- Source
- mongodb/agent-skills · skills/mongodb-mcp-setup · commit 155bb9c
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
- Also distributed in
- mongodb/agent-skills
AutoGineer is not affiliated with or endorsed by MongoDB or MongoDB.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download mongodb-mcp-setup.zip