> ## Documentation Index
> Fetch the complete documentation index at: https://docs.windsurf.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Model Context Protocol (MCP)

> Integrează servere MCP cu Cascade pentru a accesa instrumente personalizate precum GitHub, baze de date și API-uri. Configurează transporturile stdio, HTTP și SSE cu controale de administrare pentru Teams.

**MCP (Model Context Protocol)** este un protocol care permite modelelor LLM să acceseze instrumente și servicii personalizate.
Un client MCP (Cascade, în acest caz) poate trimite cereri către servere MCP pentru a accesa instrumentele pe care acestea le furnizează.
Cascade este acum integrat nativ cu MCP, permițându-ți să îți aduci propria selecție de servere MCP pe care Cascade să le folosească.
Consultă [documentația oficială MCP](https://modelcontextprotocol.io/) pentru mai multe informații.

> [!NOTE]
>
> Utilizatorii Enterprise trebuie să activeze manual această opțiune din setări

## Adăugarea unui nou MCP

MCP-uri noi pot fi adăugate din MCP Marketplace, la care puteți ajunge
făcând clic pe pictograma `MCPs` din meniul din dreapta sus al panoului Cascade sau din
secțiunea `Windsurf Settings` > `Cascade` > `MCP Servers`.

Dacă nu găsiți MCP-ul dorit, îl puteți adăuga manual editând direct fișierul `mcp_config.json`.

MCP-urile oficiale vor apărea cu o bifă albastră, indicând faptul că sunt create de compania serviciului părinte.

Când faceți clic pe un MCP, apăsați pur și simplu pe `Install` pentru a expune serverul și instrumentele sale către Cascade.

Windsurf suportă trei [tipuri de transport](https://modelcontextprotocol.io/docs/concepts/transports) pentru serverele MCP:
`stdio`, `Streamable HTTP` și `SSE`.

Windsurf suportă, de asemenea, OAuth pentru fiecare tip de transport.

Pentru serverele `http`, URL-ul ar trebui să corespundă endpoint-ului și să arate similar cu `https://<your-server-url>/mcp`.

![](https://mintcdn.com/codeium/Rm_zdSOuabDsfa9L/assets/windsurf/cascade/mcp/mcp-plugin-store.png?fit=max\&auto=format\&n=Rm_zdSOuabDsfa9L\&q=85\&s=1f6f2165d7017097ebb08cba65d43362)

## Configurarea instrumentelor MCP

Fiecare MCP are un anumit număr de instrumente la care are acces. Cascade are o limită de 100 de instrumente la care poate avea acces în același timp.

Pe fiecare pagină de setări a unui MCP, poți activa sau dezactiva instrumentele pentru care dorești să permiți accesul. Pentru a deschide setările unui MCP, fă clic pe pictograma `MCPs` din meniul din colțul din dreapta sus al panoului Cascade și apoi fă clic pe MCP-ul dorit.

![](https://mintcdn.com/codeium/Rm_zdSOuabDsfa9L/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max\&auto=format\&n=Rm_zdSOuabDsfa9L\&q=85\&s=167fd87ffb6cf42228f6e62ff8cb6596)

## mcp\_config.json

Fișierul `~/.codeium/windsurf/mcp_config.json` este un fișier JSON care conține o listă de servere la care Cascade se poate conecta.

Iată un exemplu de configurație, care definește un singur server pentru GitHub:

```json theme={null}
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<TOKEN_PERSONAL_DE_ACCES>"
      }
    }
  }
}
```

Asigurați-vă că transmiteți argumentele și variabilele de mediu necesare pentru serverele pe care doriți să le folosiți.

Consultați [repository-ul oficial de referință pentru servere MCP](https://github.com/modelcontextprotocol/servers) sau [OpenTools](https://opentools.com/) pentru exemple de servere.

### Exemple populare de servere MCP

Mai jos găsiți exemple de configurare pentru câteva servere MCP utilizate frecvent. Acestea pot fi adăugate în fișierul `mcp_config.json`.

> [accordion] GitHub
>
> Administrare de repository-uri, operațiuni cu fișiere și integrare cu GitHub API.
>
> Serverul MCP GitHub oferă instrumente pentru administrarea repository-urilor, operațiuni cu fișiere, urmărirea issue-urilor și administrarea pull request-urilor.
>
> **Folosind npx:**
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "github": {
>       "command": "npx",
>       "args": ["-y", "@modelcontextprotocol/server-github"],
>       "env": {
>         "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
>       }
>     }
>   }
> }
> ```
>
> **Folosind Docker:**
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "github": {
>       "command": "docker",
>       "args": [
>         "run", "-i", "--rm",
>         "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
>         "ghcr.io/github/github-mcp-server"
>       ],
>       "env": {
>         "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
>       }
>     }
>   }
> }
> ```
>
> Pentru a crea un personal access token, accesați [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).

> [accordion] Slack
>
> Administrarea canalelor și capabilități de mesagerie pentru workspace-urile Slack.
>
> Serverul MCP Slack permite administrarea canalelor, mesageria și interacțiunile în workspace-uri.
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "slack": {
>       "command": "npx",
>       "args": ["-y", "@anthropic/mcp-server-slack"],
>       "env": {
>         "SLACK_BOT_TOKEN": "<YOUR_SLACK_BOT_TOKEN>",
>         "SLACK_TEAM_ID": "<YOUR_SLACK_TEAM_ID>"
>       }
>     }
>   }
> }
> ```
>
> Pentru a configura un Slack bot token:
>
> 1. Creați o Slack App pe [api.slack.com/apps](https://api.slack.com/apps)
> 2. Adăugați scope-urile OAuth necesare (de ex., `channels:read`, `chat:write`, `users:read`)
> 3. Instalați aplicația în workspace și copiați Bot User OAuth Token

> [accordion] PostgreSQL
>
> Acces read-only la baza de date cu capabilități de inspectare a schemei.
>
> Serverul MCP PostgreSQL oferă acces read-only la baze de date PostgreSQL, inclusiv inspectarea schemei și execuția interogărilor.
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "postgres": {
>       "command": "npx",
>       "args": ["-y", "@modelcontextprotocol/server-postgres"],
>       "env": {
>         "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
>       }
>     }
>   }
> }
> ```
>
> > [!WARNING]
> >
> > Serverul PostgreSQL oferă implicit acces read-only, pentru siguranță. Asigurați-vă că stringul de conexiune folosește credențiale adecvate, cu permisiuni limitate.

> [accordion] Filesystem
>
> Operațiuni sigure pe fișiere, cu controale de acces configurabile.
>
> Serverul MCP Filesystem oferă acces sigur la fișiere și directoare locale, cu controale de acces configurabile.
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "filesystem": {
>       "command": "npx",
>       "args": [
>         "-y", "@modelcontextprotocol/server-filesystem",
>         "/path/to/allowed/directory"
>       ]
>     }
>   }
> }
> ```
>
> Puteți specifica mai multe directoare permise, adăugând argumente suplimentare de tip path. Doar fișierele din aceste directoare vor fi accesibile.

> [accordion] Brave Search
>
> Căutare web și locală folosind Brave Search API.
>
> Serverul MCP Brave Search permite căutare pe web folosind Brave Search API.
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "brave-search": {
>       "command": "npx",
>       "args": ["-y", "@anthropic/mcp-server-brave-search"],
>       "env": {
>         "BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>"
>       }
>     }
>   }
> }
> ```
>
> Pentru a obține un Brave API key, înregistrați-vă la [brave.com/search/api](https://brave.com/search/api/).

> [accordion] Memory
>
> Sistem de memorie persistentă bazat pe knowledge graph.
>
> Serverul MCP Memory oferă un sistem de memorie persistentă folosind un knowledge graph, permițând Cascade să își amintească informații între sesiuni.
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "memory": {
>       "command": "npx",
>       "args": ["-y", "@modelcontextprotocol/server-memory"]
>     }
>   }
> }
> ```
>
> Serverul de memorie stochează datele local și le păstrează între sesiuni, fiind util pentru menținerea contextului despre proiecte, preferințe și informații învățate.

### MCP-uri HTTP la distanță

Este important de menționat că, pentru MCP-urile HTTP la distanță, configurația este puțin
diferită și necesită un câmp `serverUrl` sau `url`.

Iată un exemplu de configurație pentru un server HTTP:

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<url-ul-serverului-tau>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}
```

### Interpolare configurație

Fișierul `~/.codeium/windsurf/mcp_config.json` gestionează interpolarea
variabilelor de mediu în aceste câmpuri: `command`, `args`, `env`, `serverUrl`, `url` și
`headers`.

Iată un exemplu de configurație care folosește o variabilă de mediu `AUTH_TOKEN`
în `headers`.

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "Bearer ${env:AUTH_TOKEN}"
      }
    }
  }
}
```

## Setări de administrare (Teams & Enterprises)

Administratorii echipei pot activa sau dezactiva accesul la MCP pentru echipa lor și pot, de asemenea, să aprobe servere MCP pe care echipa le poate folosi:

> [card] [Setări MCP pentru echipă](https://windsurf.com/team/settings)
>
> Setări MCP configurabile pentru echipa dvs.

> [!WARNING]
>
> Linkul de mai sus va funcționa doar dacă aveți privilegii de administrator pentru echipa dvs.

În mod implicit, utilizatorii dintr-o echipă își pot configura propriile servere MCP. Totuși, odată ce aprobați chiar și un singur server MCP, **toate serverele neaprobate vor fi blocate** pentru echipa dvs.

> [!NOTE]
>
> ID-ul serverului din lista albă trebuie să se potrivească, inclusiv majuscule și minuscule, cu numele cheii folosit în fișierul `mcp_config.json` al utilizatorului.

### Cum funcționează potrivirea serverului

Când adaugi pe lista de permisiuni un server MCP, sistemul folosește **potrivire pe baza tiparelor regex** cu următoarele reguli:

* **Potrivire pe întregul șir**: Toate tiparele sunt ancorate automat (încadrate cu `^(?:pattern)$`) pentru a preveni potrivirile parțiale
* **Câmpul Command**: Trebuie să se potrivească exact sau conform tiparului tău regex
* **Tabloul Arguments**: Fiecare argument este verificat individual față de tiparul corespunzător
* **Lungimea tabloului**: Numărul de argumente trebuie să se potrivească exact între lista de permisiuni și configurația utilizatorului
* **Caractere speciale**: Caractere precum `$`, `.`, `[`, `]`, `(`, `)` au semnificație specială în regex și trebuie escape‑uite cu `\` dacă vrei potrivire literală

### Opțiuni de configurare

> [accordion] Opțiunea 1: Implicit din Plugin Store (Recomandat)
>
> Lăsați câmpul Server Config (JSON) necompletat pentru a folosi configurația implicită din Windsurf MCP Plugin Store.
>
> **Configurație whitelist pentru administratori:**
>
> * **Server ID**: `github-mcp-server`
> * **Server Config (JSON)**: *(lăsați necompletat)*
>
> ```json theme={null}
> {}
> ```
>
> **Config utilizator corespunzătoare (`mcp_config.json`):**
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "github-mcp-server": {
>       "command": "docker",
>       "args": [
>         "run",
>         "-i",
>         "--rm",
>         "-e",
>         "GITHUB_PERSONAL_ACCESS_TOKEN",
>         "ghcr.io/github/github-mcp-server"
>       ],
>       "env": {
>         "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
>       }
>     }
>   }
> }
> ```
>
> Acest lucru le permite utilizatorilor să instaleze serverul GitHub MCP cu orice configurație validă, atâta timp cât ID-ul serverului corespunde intrării din Plugin Store.

> [accordion] Opțiunea 2: Configurație identică
>
> Furnizați configurația exactă pe care utilizatorii trebuie să o folosească. Utilizatorii trebuie să respecte întocmai această configurație.
>
> **Configurație whitelist pentru administratori:**
>
> * **Server ID**: `github-mcp-server`
> * **Server Config (JSON)**:
>
> ```json theme={null}
> {
>   "command": "docker",
>   "args": [
>     "run",
>     "-i",
>     "--rm",
>     "-e",
>     "GITHUB_PERSONAL_ACCESS_TOKEN",
>     "ghcr.io/github/github-mcp-server"
>   ],
>   "env": {
>     "GITHUB_PERSONAL_ACCESS_TOKEN": ""
>   }
> }
> ```
>
> **Config utilizator corespunzătoare (`mcp_config.json`):**
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "github-mcp-server": {
>       "command": "docker",
>       "args": [
>         "run",
>         "-i",
>         "--rm",
>         "-e",
>         "GITHUB_PERSONAL_ACCESS_TOKEN",
>         "ghcr.io/github/github-mcp-server"
>       ],
>       "env": {
>         "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
>       }
>     }
>   }
> }
> ```
>
> Utilizatorii trebuie să folosească exact această configurație — orice abatere în `command` sau `args` va fi blocată. Secțiunea `env` poate avea valori diferite.

> [accordion] Opțiunea 3: Modele regex flexibile
>
> Utilizați modele regex pentru a permite variații în configurațiile utilizatorilor, menținând în același timp controalele de securitate.
>
> **Configurație whitelist pentru administratori:**
>
> * **Server ID**: `python-mcp-server`
> * **Server Config (JSON)**:
>
> ```json theme={null}
> {
>   "command": "python3",
>   "args": ["/.*\\.py", "--port", "[0-9]+"]
> }
> ```
>
> **Config utilizator corespunzătoare (`mcp_config.json`):**
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "python-mcp-server": {
>       "command": "python3",
>       "args": ["/home/user/my_server.py", "--port", "8080"],
>       "env": {
>         "PYTHONPATH": "/home/user/mcp"
>       }
>     }
>   }
> }
> ```
>
> Acest exemplu oferă flexibilitate utilizatorilor, menținând securitatea:
>
> * Regexul `/.*\\.py` corespunde oricărei căi către un fișier Python, de tipul `/home/user/my_server.py`
> * Regexul `[0-9]+` corespunde oricărui port numeric, precum `8080` sau `3000`
> * Utilizatorii pot personaliza căile și porturile, în timp ce administratorii se asigură că sunt executate doar scripturi Python

### Modele Regex comune

| Pattern | Potriviri | Exemplu |
| - | - | - |
| `.*` | Orice șir | `/home/user/script.py` |
| `[0-9]+` | Orice număr | `8080`, `3000` |
| `[a-zA-Z0-9_]+` | Alfanumeric + underscore | `api_key_123` |
| `\\$HOME` | Literal „\$HOME” | `$HOME` (fără expandare) |
| `\\.py` | Literal „.py” | `script.py` |
| `\\[cli\\]` | Literal „\[cli]” | `mcp[cli]` |

## Note

### Ghiduri de configurare pentru administratori

* **Variabile de mediu**: Secțiunea `env` nu este supusă potrivirii cu regex și poate fi configurată liber de utilizatori
* **Instrumente dezactivate**: Array-ul `disabledTools` este gestionat separat și nu intră în potrivirea pe baza listei albe
* **Sensibilitate la majuscule/minuscule**: Toate potrivirile sunt sensibile la majuscule/minuscule
* **Gestionarea erorilor**: Modelele regex invalide vor fi înregistrate și vor duce la refuzarea accesului
* **Testare**: Testează cu atenție modelele regex — modele prea restrictive pot bloca scenarii de utilizare legitime

### Depanare

Dacă utilizatorii raportează că serverele lor MCP nu funcționează după includerea pe lista de permise:

1. **Verificați potrivirea exactă**: Asigurați-vă că tiparul din lista de permise se potrivește exact cu configurația utilizatorului
2. **Verificați escaparea în regex**: Caracterele speciale pot necesita escapare (de ex., `\.` pentru puncte „literal”)
3. **Examinați logurile**: Tiparele regex nevalide sunt înregistrate cu avertismente
4. **Testați tiparele**: Folosiți un tester regex pentru a verifica dacă tiparele funcționează conform așteptărilor

Rețineți: Odată ce permiteți orice server, **toate celelalte servere sunt blocate automat** pentru membrii echipei.

### Informații generale

* Deoarece apelurile de instrumente MCP pot invoca cod scris de implementatori de server arbitrar, nu ne asumăm răspunderea
  pentru eșecurile acestor apeluri. În reiterare:
* În prezent acceptăm [tools](https://modelcontextprotocol.io/docs/concepts/tools), [resources](https://modelcontextprotocol.io/docs/concepts/resources) și [prompts](https://modelcontextprotocol.io/docs/concepts/prompts) ale unui server MCP.
