Repository containing reference implementations of MCP (Model Context Protocol) servers for managing and interacting with Oracle products. Each MCP server under src/ may be written in a different programming language, demonstrating MCP’s language-agnostic approach.

The Model Context Protocol (MCP) enables standardized, language-agnostic machine-to-machine workflows across data, models, and cloud resources. MCP servers implement specific tool suites, exposing them to MCP-compatible clients.

• Proof-of-concept/Reference implementations:
  This repository is not intended for production use; servers are provided as reference and for exploration, prototyping, and learning.

• Polyglot architecture:
  Each src/<server-name>/ directory represents a distinct MCP server, and these may use Python, Node.js, Java, or other languages.

• Supported OS: Linux, macOS, or Windows (varies by server; check server README)
• Git (for cloning this repository)
• Internet access (for downloading dependencies)
• Cloud access: Some servers require Oracle Cloud Infrastructure (OCI) credentials and configuration (OCI docs)

Note:
Each MCP server has its own specific requirements (e.g., language runtime version, libraries).
Always see the respective src/<server>/README.md for detailed setup instructions.

1. Clone this repository:

   git clone https://github.com/oracle/mcp.git
   cd mcp

2. List available MCP servers:

   ls src/

3. Read the appropriate server's README for setup instructions:

   cat src/<server-name>/README.md

   • Example: For the Python-based DBTools MCP server:

     cd src/dbtools-mcp-server/
     cat README.md
     

4. Typical Python Server Setup Example:

   python3 -m venv venv
   source venv/bin/activate        # On Windows: venv\Scripts\activate
   pip install -r requirements-dev.txt

   (For Node.js/Java/other servers, follow respective instructions in that server’s README)

5. Build and Install servers in the current virtual environment

   make build
   make install

For OCI MCP servers, you'll need to install and authenticate using the OCI CLI.

1. Install the OCI CLI
2. Configure your OCI CLI profile

oci session authenticate --region=<region> --tenancy-name=<tenancy_name>

where: is the region you would like to authenticate in (e.g. us-phoenix-1) <tenancy_name> is the name of your OCI tenancy

All actions are performed with the permissions of the configured OCI CLI profile. We advise least-privilege IAM setup, secure credential management, safe network practices, secure logging, and warn against exposing secrets.

Remember to refresh the session once it expires with:

oci session authenticate --profile-name <profile_name> --region <region> --auth security_token

Each MCP server exposes endpoints that your client can connect to. To enable this connection, just add the relevant server to your MCP client’s configuration file. You can find the list of servers under the src folder.

Refer to the sections below for client-specific configuration instructions.

{
  "mcpServers": {
    "oracle-oci-api-mcp-server": {
      "type": "stdio",
      "command": "uv",
      "args": [
        "run",
        "oracle.oci-api-mcp-server"
      ],
      "env": {
        "OCI_CONFIG_PROFILE": "<profile_name>",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

{
  "mcpServers": {
    "oracle-oci-api-mcp-server": {
      "type": "stdio",
      "command": "uv",
      "args": [
        "run",
        "oracle.oci-api-mcp-server"
      ],
      "env": {
        "OCI_CONFIG_PROFILE": "<profile_name>",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

{
  "mcpServers": {
    "oracle-oci-api-mcp-server": {
      "type": "stdio",
      "command": "uv",
      "args": [
        "run",
        "oracle.oci-api-mcp-server"
      ],
      "env": {
        "VIRTUAL_ENV": "<path to your cloned repo>/oci-mcp/.venv",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

.
├── src/
│   ├── dbtools-mcp-server/     # MCP server (Python example)
│   ├── another-mcp-server/     # (Possible Node.js, Java, or other implementation)
│   └── ...
├── LICENSE.txt
├── README.md
├── CONTRIBUTING.md
└── SECURITY.md

Each server subdirectory includes its own README.md with language/runtime details, installation, and usage.

You can modify the settings of your MCP client to run your local server. Open your client json settings file and update it as needed. For instance:

{
  "mcpServers": {
    "oracle-oci-api-mcp-server": {
      "type": "stdio",
      "command": "uv",
      "args": [
        "run",
        "oracle.oci-api-mcp-server"
      ],
      "env": {
        "VIRTUAL_ENV": "<path to your cloned repo>/oci-mcp/.venv",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

where <absolute path to your server code> is the absolute path to the server code, for instance /Users/myuser/dev/oci-mcp/src/oci-identity-mcp-server/oracle/oci_identity_mcp_server.

The Model Context Protocol (MCP) provides Inspector which is a developer tool for testing and debugging MCP servers. More information on Inspector can be found in the documentation.

The Inspector runs directly through npx without requiring installation. For instance, to inspect your locally developed server, you can run:

npx @modelcontextprotocol/inspector \
  uv \
  --directory <absolute path to your server code> \
  run \
  server.py

Inspector will run your server on localhost (for instance: http://127.0.0.1:6274) which should automatically open the tool for debugging and development.

This project welcomes contributions from the community. Before submitting a pull request, please review our contribution guide.

Please consult the security guide for our responsible security vulnerability disclosure process.

Copyright (c) 2025 Oracle and/or its affiliates.

Released under the Universal Permissive License v1.0 as shown at
https://oss.oracle.com/licenses/upl/.

Developers choosing to distribute a binary implementation of this project are responsible for obtaining and providing all required licenses and copyright notices for the third-party code used in order to ensure compliance with their respective open source licenses.

Users are responsible for their local environment and credential safety. Different language model selections may yield different results and performance.