---
canonical: https://docs.jentic.com/guides/mcp/Local%20MCP/vscode/
representation: markdown-alternate
# Canonical page: https://docs.jentic.com/guides/mcp/Local%20MCP/vscode/
# This is the Markdown alternate of the page above.
title: "Local Jentic MCP Server in VS Code (Deprecated)"
description: >-
  Configure the local Jentic MCP server in Visual Studio Code so you can search, load,
  and execute thousands of external APIs directly inside your VS Code editor.
---

# Jentic MCP + Visual Studio Code

!!! warning "Deprecated"
    This page is **deprecated** and kept only for reference. It describes the retired hosted
    `app.jentic.com` platform and the `jentic-sdks` MCP plugin. To use Jentic over MCP today, see the
    [MCP overview](../remote-mcp.md) — search the API directory over the hosted MCP server, and connect
    your **self-hosted [Jentic One](../../../reference/jentic-one/index.md)** instance as a custom connector.

> **Goal** — In a few minutes, you'll enable Jentic MCP tools in Visual Studio Code, allowing you to **search**, **load**, and **execute** external APIs directly in your coding workflow.

## What you'll get

With Jentic MCP configured in Visual Studio Code, you'll gain access to powerful tools:

### Tools available

| Tool available in Visual Studio Code | What it does |
|--------------------------------------|--------------|
| **search_apis** | Type what you need (e.g., "Send Discord Message", "Find New York Times Articles") and MCP lists matching APIs. |
| **load_execution_info** | See the details of any API you found - what information it needs and how to use it. |
| **execute** | Actually use the API - provide the required information and get results back in the chat. |


## Before you start

Ensure you have the following installed and configured:

| You need | Why | Quick install |
|---|---|---|
| **Python ≥ 3.11** | Required for uv/uvx and Jentic CLI. | [python.org](https://www.python.org/downloads/) |
| **VS Code (latest)** | The editor where you'll use MCP. | [code.visualstudio.com](https://code.visualstudio.com/download) |
| **GitHub Copilot** | MCP servers extend the agent capabilities of Copilot Chat. | [Marketplace](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot) |
| **uv / uvx** runtime | Launcher that runs the Jentic MCP server. | Install with pip: `pip install uv` (any OS)  **or**  with Homebrew (macOS): `brew install uv`<br/>_If you have trouble with `uvx`, see [Making Visual Studio Code See `uvx`](#making-visual-studio-code-see-uvx) below._ |

### 1. Create an Agent & get your Agent API Key

1. Go to **[app.jentic.com/sign-in](https://app.jentic.com/sign-in)** and sign in to your account.
2. In **Credentials**, add any API secrets you'll use (e.g., Discord bot token, NYT key). These credentials will be securely stored in Jentic and automatically used by your agent.
3. Open **Agents → New Agent**, select which APIs/workflows this agent can access, then **Generate API Key**.

   * Keys are **scoped** to the APIs you selected and shown **once**.
   * **Recommended:** Store all API credentials in Jentic's Credentials section rather than using environment variables.
4. Set the Agent API Key as an environment variable so VS Code/Copilot can use it:

**macOS / Linux**

```bash
export JENTIC_AGENT_API_KEY="<your-agent-api-key>"
```

**Windows (PowerShell)**

```powershell
setx JENTIC_AGENT_API_KEY "<your-agent-api-key>"
$env:JENTIC_AGENT_API_KEY = "<your-agent-api-key>"  # current session
```

> ✅ No more `jentic register` or `JENTIC_UUID`. Use **`JENTIC_AGENT_API_KEY`** from the **Agents** page.


## 2. Configure MCP in Visual Studio Code (**Global recommended**)

The easiest way is to set this up globally so Jentic works in all your projects:

1. Open the **Command Palette** (macOS **⌘⇧P** / Windows/Linux **Ctrl+Shift+P**, or **F1**).
2. Run **MCP: Open User Configuration** — this opens/creates your global **`mcp.json`**.

   ![MCP Open User Configuration command](assets/images/mcpOpenUserConfig.png)

3. Paste the JSON and replace `<your-api-key>`, then **Save**:

```jsonc
{
  "servers": {
    "jentic": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/jentic/jentic-sdks.git@main#subdirectory=mcp",
        "mcp"
      ],
      "env": {
        "JENTIC_AGENT_API_KEY": "<your-agent-api-key>"
      }
    }
  }
}
```

> **Can't find "MCP: Open User Configuration"?** Try updating VS Code (macOS: gear icon → Check for Updates) or see the FAQ below.

### (Optional) Per‑project setup
If you want to share config with a repo/team or keep it project‑scoped, create `.vscode/mcp.json` in your workspace instead. You can also run **MCP: Add Server** and choose **Workspace** to have VS Code create/populate the file for you.

> **Note**: Cursor and VS Code have separate user profiles, but workspace config (`.vscode/mcp.json`) works across both editors.

## 3. Stop repeated permission prompts
When Copilot wants to run a Jentic tool, VS Code asks for permission. Click **Continue ▾** and choose **Always allow** – never ask again (all sessions/workspaces).

![Always Allow permission prompt](assets/images/alwaysAllow.png)


## 4. Managing API Credentials

**Recommended approach:** Store all API credentials in Jentic's Credentials section when creating your agent. This keeps credentials secure and centralized.

If you need to add credentials for APIs you want to use:
1. Go back to [app.jentic.com](https://app.jentic.com) and sign in.
2. Navigate to **Credentials** and add any additional API keys, tokens, or secrets needed.
3. Update your agent to include the new credentials, or create a new agent with the updated credentials.

> **Note:** Only the `JENTIC_AGENT_API_KEY` should be set as an environment variable. All other API credentials should be stored in Jentic's Credentials section, not as environment variables in your MCP configuration.

### Optional: Using Environment Variables

If you prefer to use environment variables directly instead of storing credentials in Jentic, you can add them to your MCP configuration:

1. Open the same `mcp.json` file.
2. Insert or update the **`env`** block *inside* the `jentic` server.
3. Save the file (you may need to restart VS Code).

**Example configuration with environment variables:**
```jsonc
{
  "servers": {
    "jentic": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/jentic/jentic-sdks.git@main#subdirectory=mcp",
        "mcp"
      ],
      "env": {
        "JENTIC_AGENT_API_KEY": "<your-agent-api-key>",
        "DISCORD_BOTTOKEN": "<your-discord-bot-token>",
        "OPENAI_API_KEY": "<your-openai-api-key>"
      }
    }
  }
}
```

> **Security tip:** The `mcp.json` file is plain text. Ensure it's stored securely, especially if it contains sensitive API keys.

## 5. Use MCP tools in Agent Mode

1.  Open the **Chat** view (Windows/Linux: Ctrl+Alt+I; macOS: Control–Command–I). Switch to **Agent mode**.
2.  When prompted to trust the Jentic server, choose **Always allow** (or **Current workspace**) to avoid future prompts.
3.  Click the **Tools** icon to see available tools, or reference a tool in your prompt with `#tool`.
4.  Enter a prompt. Copilot will automatically invoke tools as needed, asking for your confirmation before running them.

    > You can also directly reference a tool in your prompt by typing `#` followed by the tool name (e.g., `#search_apis`).

## 6. If something doesn’t work
| What you see / Problem | Try this |
| :--- | :--- |
| Jentic MCP tools not showing in VS Code | Check your `.vscode/mcp.json` file for syntax errors (e.g., missing commas, incorrect brackets). Ensure VS Code was fully restarted after any changes. Check the server logs by running `MCP: List Servers`, selecting `jentic`, and choosing `Show Output`. |
| "command not found: uvx" (in logs or error) | `uvx` is not in a path VS Code can see. See "Making Visual Studio Code See `uvx`" below for details. |
| API calls fail (e.g., 401/403 errors) | The API likely requires authentication. Use `/load_execution_info` to check its requirements, then add the necessary credentials to Jentic's Credentials section and ensure your agent has access to them. Restart VS Code. |
| "MCP: Open User Configuration" doesn't appear in Command Palette | **macOS users**: Update VS Code first (gear icon → Check for Updates). **Alternative**: Manually create the file at `~/Library/Application Support/Code/User/mcp.json` (macOS), `%APPDATA%\Code\User\mcp.json` (Windows), or `~/.config/Code/user/mcp.json` (Linux). |

### Making Visual Studio Code See `uvx`
VS Code is a GUI app; it **doesn’t read your shell profile**, so binaries added to `PATH` in `.zshrc`/`.bashrc` may be invisible. Choose **one** of these options:

#### Option A – Homebrew / System package (macOS & Linux)
* Homebrew (macOS) or your distro’s package manager / a `sudo pip install uv` drops `uvx` somewhere VS Code already looks:
    * `/usr/local/bin` on Intel Macs & most Linux distros
    * `/opt/homebrew/bin` on Apple Silicon

If `which uvx` returns one of these paths, you’re good – skip this section.

#### Option B – pip / pipx / pyenv (user-local installs)
If `uvx` lives in a user-local directory, expose it via a **symlink** (macOS/Linux) or by **adding the folder to PATH** (Windows).

* macOS / Linux – symlink
  ```bash
  sudo ln -sf "$(which uvx)" /usr/local/bin/uvx   # use /opt/homebrew/bin on Apple Silicon
  sudo ln -sf "$(which uv)"  /usr/local/bin/uv
  ```
* Windows – PATH
    1. Locate the folder containing `uvx.exe` (e.g. `%USERPROFILE%\AppData\Roaming\Python\Python311\Scripts`).
    2. Add that folder to *Path* in **Environment Variables…**.
    3. Restart VS Code (and any open terminals).

#### Option C – Hard-code the full path
Alternatively, you can skip creating symlinks and directly specify the full path to the binary in the configuration file.

For more details on managing MCP servers in VS Code, see the [Official Visual Studio Code MCP server docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).


### Additional FAQ

**Q: Do Cursor and VS Code share MCP configurations?**  
Cursor and VS Code have **separate user profiles**, so global configurations don't sync between them. However, **workspace config** (`.vscode/mcp.json`) works across both editors.

**Q: Should I use global or workspace configuration?**  
- **Global** (recommended): Use when you want Jentic available in all projects
- **Workspace**: Use when sharing config with a team or keeping it project-specific