A little background on why this post. I have been experimenting with various command-line code AI agents/tools for the last couple of weeks(I know I was late to this party). While doing research into how other people are using Claude Code, I came across this Reddit post about Rovo Dev CLI from Atlassian. I was skeptical at first, but I started using it a couple of days ago, and I find it useful so far, coding new features in existing repos or coding apps from scratch. I will write about my experience with it separately.

So I started looking into how else I can use rovo dev cli for tasks other than coding. This is what led to this post.

To the post now….

Let's dive into how you can connect third-party MCP (Model Context Protocol) servers to unlock a whole world of new capabilities.

What is Rovo Dev CLI?

First things first - if you're new to Rovo Dev CLI, it's Atlassian's powerful AI-powered development tool that helps you code, debug, and manage projects right from your terminal. Think of it as your AI pair programmer that can understand your codebase, execute commands, and even integrate with your Atlassian tools. You can learn more about it in the official Rovo Dev CLI documentation.

What Are MCP Servers?

MCP servers are like plugins that give Rovo Dev CLI access to external tools and data sources. Want to connect to GitHub? There's an MCP server for that. Need file system access? Yep, there's one for that too. These servers act as bridges between Rovo Dev CLI and the tools you use every day.

Setting Up Your First MCP Server

All MCP server configurations live in a single file: ~/.rovodev/mcp.json. Let's create this file and start adding some servers!

Step 1: Create the Configuration Directory

# Create the directory if it doesn't exist
mkdir -p ~/.rovodev

Step 2: Create Your mcp.json File

Start with a basic structure:

{
  "mcpServers": {

  }
}

Now let's fill it with some servers!

Method 1: TypeScript Servers with NPX (Temporary)

NPX is perfect when you want to test servers without installing them permanently. It downloads, runs, and cleans up automatically.

Quick Test

# Test a server directly first
npx -y @modelcontextprotocol/server-everything

Add to Configuration

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-everything"]
    },
    "memory": {
      "command": "npx", 
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Pros: No permanent installation, always gets latest version Cons: Slower startup as it downloads each time

Method 2: TypeScript Servers with NPX (Permanent)

Want faster startup times? Install the servers globally first:

# Install servers permanently
npm install -g @modelcontextprotocol/server-everything
npm install -g @modelcontextprotocol/server-memory

Then use them without the download flag:

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-everything"]
    }
  }
}

Method 3: Python Servers with UV Tool (Temporary)

UV is the modern Python package runner - think of it as Python's answer to NPX. However, you need a recent version of UV for this to work.

Check Your UV Version

uv --version

You need UV 0.4.0 or later for the tool subcommand.

If You Have New UV

# Test first
uv tool run mcp-server-git

{
  "mcpServers": {
    "git": {
      "command": "uv",
      "args": ["tool", "run", "mcp-server-git"]
    }
  }
}

Method 4: Python Servers with UVX (Temporary)

UVX is supposed to be UV's equivalent to NPX, but it's often not in the PATH by default.

Test UVX Availability

uvx --help

If it works:

{
  "mcpServers": {
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git"]
    }
  }
}

Method 5: Python Servers with PIP (Permanent)

The tried-and-true method that works everywhere:

# Install servers permanently
pip install mcp-server-git
pip install mcp-server-memory
pip install mcp-server-filesystem

# Test they work
python -m mcp_server_git

{
  "mcpServers": {
    "git": {
      "command": "python",
      "args": ["-m", "mcp_server_git"]
    },
    "memory": {
      "command": "python",
      "args": ["-m", "mcp_server_memory"]
    },
    "filesystem": {
      "command": "python",
      "args": ["-m", "mcp_server_filesystem", "/path/to/allowed/directory"]
    }
  }
}

Mixing and Matching

Here's the beauty - you can use different methods for different servers in the same configuration:

{
  "mcpServers": {
    "everything": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-everything"]
    },
    "git": {
      "command": "python",
      "args": ["-m", "mcp_server_git"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "filesystem": {
      "command": "python",
      "args": ["-m", "mcp_server_filesystem", "~/Documents"]
    }
  }
}

Adding Environment Variables

Some servers need API keys or other configuration:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

Testing Your Setup

After adding servers to your configuration:

Restart Rovo Dev CLI (this is required - no hot reload yet!)
Test the connection:
```
 What MCP servers can you use?
```
Grant permissions when prompted

Try server features:

 Use the MCP server to add two numbers: 15 and 27

Finding More MCP Servers

Want to explore more servers? Check out these resources:

Official Examples: modelcontextprotocol.io/examples
Official Repository: github.com/modelcontextprotocol/servers
Awesome Lists: Search GitHub for "awesome mcp servers"
Community Hub: mcpservers.org

Pro Tips

1. Start Small

Begin with the "everything" server - it's designed for testing and has lots of features to play with.

2. Test Servers Standalone First

Before adding to your config, test servers work independently:

npx -y @modelcontextprotocol/server-memory
# or
python -m mcp_server_git

3. Choose Your Method Based on Your Workflow

Temporary installs (npx -y, uv tool run): Great for testing and always getting latest versions
Permanent installs (npm -g, pip): Better for daily use, faster startup times

4. Keep a Backup Config

Save a working configuration before experimenting:

cp ~/.rovodev/mcp.json ~/.rovodev/mcp.json.backup

5. Use Descriptive Names

Give your servers meaningful names in the config:

{
  "mcpServers": {
    "personal-filesystem": {
      "command": "python",
      "args": ["-m", "mcp_server_filesystem", "~/Documents"]
    },
    "work-github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    }
  }
}

Troubleshooting

Server Not Recognized

Double-check your JSON syntax (trailing commas will break it!)
Restart Rovo Dev CLI after configuration changes
Test the server command manually in your terminal first

Permission Issues

Rovo Dev CLI will ask for permission to use new servers
You can change permissions later in ~/.rovodev/config.yml

Path Problems

Make sure the command is available in your PATH
For Python servers, ensure the package is installed in your current Python environment

Wrapping Up

That's it! You're now equipped to extend Rovo Dev CLI with any MCP server you can find. Whether you prefer the temporary approach with npx and uv, or permanent installations with npm and pip, you've got options.

Start with a simple server like "everything" or "memory" to get a feel for how MCP servers work, then gradually add more specialized servers for your specific workflow. The MCP ecosystem is growing rapidly, and I am sure you can find one you need already built or build your own.

Getting Started with Third-Party MCP Servers in Rovo Dev CLI

Table of contents