> ## 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</Note>

<div id="adding-a-new-mcp">
  ## Adăugarea unui nou MCP
</div>

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`.

<Frame>
  <img src="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" width="955" height="774" data-path="assets/windsurf/cascade/mcp/mcp-plugin-store.png" />
</Frame>

<div id="configuring-mcp-tools">
  ## Configurarea instrumentelor MCP
</div>

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.

<Frame>
  <img src="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" width="893" height="639" data-path="assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png" />
</Frame>

<div id="mcp_configjson">
  ## mcp\_config.json
</div>

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.

<div id="popular-mcp-server-examples">
  ### Exemple populare de servere MCP
</div>

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`.

<AccordionGroup>
  <Accordion title="GitHub" description="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>

  <Accordion title="Slack" description="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>

  <Accordion title="PostgreSQL" description="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.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="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>

  <Accordion title="Brave Search" description="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>

  <Accordion title="Memory" description="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.
  </Accordion>
</AccordionGroup>

<div id="remote-http-mcps">
  ### MCP-uri HTTP la distanță
</div>

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"
      }
    }
  }
}
```

<div id="config-interpolation">
  ### Interpolare configurație
</div>

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}"
      }
    }
  }
}
```

<div id="admin-controls-teams-enterprises">
  ## Setări de administrare (Teams & Enterprises)
</div>

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 title="Setări MCP pentru echipă" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Setări MCP configurabile pentru echipa dvs.
</Card>

<Warning>Linkul de mai sus va funcționa doar dacă aveți privilegii de administrator pentru echipa dvs.</Warning>

Î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.</Note>

<div id="how-server-matching-works">
  ### Cum funcționează potrivirea serverului
</div>

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ă

<div id="configuration-options">
  ### Opțiuni de configurare
</div>

<AccordionGroup>
  <Accordion title="Opțiunea 1: Implicit din Plugin Store (Recomandat)" description="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>

  <Accordion title="Opțiunea 2: Configurație identică" description="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>

  <Accordion title="Opțiunea 3: Modele regex flexibile" description="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
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Modele Regex comune
</div>

| 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]`               |

<div id="notes">
  ## Note
</div>

<div id="admin-configuration-guidelines">
  ### Ghiduri de configurare pentru administratori
</div>

* **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

<div id="troubleshooting">
  ### Depanare
</div>

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.

<div id="general-information">
  ### Informații generale
</div>

* 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.