Przejdź do treści

Przewodnik instalacji

Uruchom wszystko w mniej niż 5 minut. Ten przewodnik obejmuje konfigurację dla 23 klientów MCP, w tym Claude Code, Claude Desktop, Cursor, VS Code / GitHub Copilot i Devin Desktop (Windsurf) i innych.

Wymagania wstępne: Potrzebujesz klucza API z app.maguyva.ai oraz połączonego repozytorium GitHub.

Konfiguracja środowiska

#

Najpierw ustaw klucz API w zmiennej środowiskowej. Pomiń repository, gdy Twój klient MCP dostarcza domyślne ustawienie dla żądania lub gdy klucz ma dostęp dokładnie do jednego repozytorium; w przeciwnym razie przekaż je jawnie.

macOS/Linux (Bash/Zsh)

# 
# Add to your shell profile for persistence:
echo 'export MAGUYVA_API_KEY="mgv_xxxx"' >> ~/.zshrc  # or ~/.bashrc
source ~/.zshrc  # reload

Windows (PowerShell)

# 
# Make it persist in your profile:
'$Env:MAGUYVA_API_KEY="mgv_xxxx"' | Out-File -Append $PROFILE
. $PROFILE

Zastąp mgv_xxxx swoim rzeczywistym kluczem API z app.maguyva.ai.

Konfiguracja klienta

#

Wybierz poniżej swojego klienta MCP, aby zobaczyć szczegółowe instrukcje konfiguracji.

Uwaga dotycząca kompatybilności: Maguyva wykorzystuje standardowy MCP. Każdy klient obsługujący MCP może połączyć się z tym samym serwerem, nawet jeśli nie napisaliśmy jeszcze dla niego oficjalnego przewodnika konfiguracji.

Claude Code

Zainstaluj plugin Maguyva z marketplace Claude Code:

Dodaj marketplace Maguyva, a następnie zainstaluj plugin (uruchom każdą komendę wewnątrz Claude Code):

/plugin marketplace add maguyva/agent-plugins
/plugin install maguyva@maguyva

/plugin install otwiera szczegóły pluginu, gdzie wybierasz zakres instalacji: tylko Ty (user), wszyscy pracujący w tym repozytorium (project) albo tylko Ty w tym repozytorium (local). Te komendy w sesji nie mają flagi --scope.

Plugin uwierzytelnia się za pomocą zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją w swojej powłoce:

export MAGUYVA_API_KEY=mgv_xxxx

Zalecane jest użycie direnv per projekt (.envrc) — klucze są przypisane do repozytorium, więc wartość per projekt odpowiada dostępowi każdego projektu. Globalny eksport w powłoce sprawdzi się, jeśli jeden klucz obejmuje całą Twoją pracę.

W zespole możesz zamiast tego uruchomić wersję powłoki obu komend z katalogu głównego repozytorium, poza Claude Code:

claude plugin marketplace add maguyva/agent-plugins --scope project
claude plugin install maguyva@maguyva --scope project

Zakres project zapisuje plugin w pliku .claude/settings.json repozytorium, który zatwierdzasz. To włącza plugin dla współpracowników, ale go nie pobiera, więc każdy z nich uruchamia komendę instalacji raz.

Konfiguracja ręczna (.mcp.json) — dla zaawansowanych
claude mcp add 
claude mcp add --transport http maguyva https://maguyva.tools/mcp --header 'Authorization: Bearer ${MAGUYVA_API_KEY}'
.mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "type": "http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w Claude Code →

Dokumentacja MCP Claude Code →

Claude Desktop

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %AppData%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Dodaj do pliku konfiguracyjnego Claude Desktop:

claude_desktop_config.json 
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "@maguyva/mcp"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

claude_desktop_config.json uruchamia tylko lokalne serwery, więc ta konfiguracja używa mostu @maguyva/mcp (wymaga Node.js / npx). Claude Desktop może też połączyć się z Maguyva jako niestandardowy konektor (Customize → Connectors) z nagłówkiem żądania authorization, ale nagłówki żądań są w becie dla ograniczonej liczby organizacji.

Co Maguyva daje w Claude Desktop →

Dokumentacja MCP Claude Desktop →

Cursor

macOS: ~/.cursor/mcp.json
Windows: %UserProfile%\.cursor\mcp.json
Linux: ~/.cursor/mcp.json

Dodaj do .cursor/mcp.json w katalogu głównym swojego projektu:

.cursor/mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MAGUYVA_API_KEY}"
      }
    }
  }
}

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Co Maguyva daje w Cursor →

Dokumentacja MCP Cursor →

VS Code / GitHub Copilot

Dodaj do .vscode/mcp.json w projekcie albo do mcp.json profilu (uruchom MCP: Open User Configuration):

.vscode/mcp.json 
{
  "servers": {
    "maguyva": {
      "type": "http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MAGUYVA_API_KEY}"
      }
    }
  }
}

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

To format VS Code (klucz servers). VS Code bierze odwołanie MAGUYVA_API_KEY ze środowiska, w którym startuje. Ścieżka Add Server preferuje teraz przenośny .mcp.json (klucz mcpServers), który czyta też GitHub Copilot CLI; ten plik nie obsługuje zmiennych wejściowych ani plików środowiskowych VS Code.

Co Maguyva daje w VS Code / GitHub Copilot →

Dokumentacja MCP VS Code / GitHub Copilot →

Devin Desktop (Windsurf)

macOS: ~/.config/devin/mcp_config.json
Windows: %APPDATA%\devin\mcp_config.json
Linux: ~/.config/devin/mcp_config.json

Windsurf nazywa się teraz Devin Desktop. Dodaj do jego pliku konfiguracji MCP:

mcp_config.json 
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MAGUYVA_API_KEY}"
      }
    }
  }
}

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Devin Local, domyślny agent, czyta ten plik od wersji 3.6; wcześniejsze wersje trzymały serwery w głównym pliku konfiguracyjnym i przenoszą je tutaj przy starcie. Starszy agent Cascade, od którego nowe rozmowy się nie zaczynają, czyta ten sam plik. Devin Desktop bierze odwołanie MAGUYVA_API_KEY ze środowiska, w którym startuje.

Co Maguyva daje w Devin Desktop (Windsurf) →

Dokumentacja MCP Devin Desktop (Windsurf) →

Codex

macOS: ~/.codex/config.toml
Windows: %UserProfile%\.codex\config.toml
Linux: ~/.codex/config.toml

Dodaj do konfiguracji Codex CLI (~/.codex/config.toml):

.codex/config.toml 
[mcp_servers.maguyva]
url = "https://maguyva.tools/mcp"
bearer_token_env_var = "MAGUYVA_API_KEY"

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Co Maguyva daje w Codex →

Dokumentacja MCP Codex →

GitHub Copilot CLI

Dodaj do ~/.copilot/mcp-config.json:

~/.copilot/mcp-config.json 
{
  "mcpServers": {
    "maguyva": {
      "type": "http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}
copilot mcp add 
copilot mcp add --transport http --header "Authorization: Bearer mgv_xxxx" maguyva https://maguyva.tools/mcp

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w GitHub Copilot CLI →

Dokumentacja MCP GitHub Copilot CLI →

Gemini CLI

macOS: ~/.gemini/settings.json
Windows: %UserProfile%\.gemini\settings.json
Linux: ~/.gemini/settings.json

Dodaj do ustawień Gemini CLI (~/.gemini/settings.json):

settings.json 
{
  "mcpServers": {
    "maguyva": {
      "httpUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Co Maguyva daje w Gemini CLI →

Dokumentacja MCP Gemini CLI →

Cline

macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows: %AppData%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Dodaj do ustawień MCP w Cline:

cline_mcp_settings.json 
{
  "mcpServers": {
    "maguyva": {
      "type": "streamableHttp",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w Cline →

Dokumentacja MCP Cline →

Goose

macOS: ~/.config/goose/config.yaml
Windows: %APPDATA%\Block\goose\config\config.yaml
Linux: ~/.config/goose/config.yaml

Dodaj do konfiguracji Goose:

config.yaml 
extensions:
  maguyva:
    name: maguyva
    type: streamable_http
    uri: https://maguyva.tools/mcp
    enabled: true
    headers:
      Authorization: Bearer mgv_xxxx
    timeout: 300

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w Goose →

Dokumentacja MCP Goose →

LM Studio

W LM Studio otwórz kartę Program na prawym pasku bocznym, wybierz Install → Edit mcp.json i dodaj:

mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Dokumentacja MCP LM Studio →

Continue

Zapisz jako .continue/mcpServers/maguyva.yaml w workspace’ie (albo dodaj wpis mcpServers do ~/.continue/config.yaml), a potem ustaw MAGUYVA_API_KEY w ~/.continue/.env:

.continue/mcpServers/maguyva.yaml 
name: Maguyva
version: 0.0.1
schema: v1
mcpServers:
  - name: maguyva
    type: streamable-http
    url: https://maguyva.tools/mcp
    requestOptions:
      headers:
        Authorization: Bearer ${{ secrets.MAGUYVA_API_KEY }}

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Continue używa serwerów MCP tylko w trybie agenta. Sekretu szuka w ~/.continue/.env, potem w .continue/.env i .env w workspace’ie, a na końcu w środowisku procesu.

Co Maguyva daje w Continue →

Dokumentacja MCP Continue →

Kiro CLI (Amazon Q Developer CLI)

macOS: ~/.kiro/settings/mcp.json
Windows: %USERPROFILE%\.kiro\settings\mcp.json
Linux: ~/.kiro/settings/mcp.json

Dodaj do konfiguracji MCP w Kiro CLI (~/.kiro/settings/mcp.json lub .kiro/settings/mcp.json w projekcie):

mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Kiro CLI zastąpiło Amazon Q Developer CLI. Podczas instalacji jednorazowo kopiuje Twoje serwery z ~/.aws/amazonq/mcp.json do ~/.kiro/settings/mcp.json, a plik .kiro/settings/mcp.json projektu ma pierwszeństwo przed plikiem użytkownika.

Dokumentacja MCP Kiro CLI (Amazon Q Developer CLI) →

PyCharm

Wklej w Settings | Tools | AI Assistant | Model Context Protocol (MCP) → Add jako konfigurację JSON: 

{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "@maguyva/mcp"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Ta konfiguracja korzysta z mostka @maguyva/mcp (wymaga Node.js / npx). Konfiguracja natywnego połączenia zdalnego dla tego klienta nie została zweryfikowana na potrzeby tego przewodnika; nie oznacza to, że klient nie obsługuje natywnych połączeń zdalnych. Maguyva działa całkowicie zdalnie — lokalnie działa tylko mostek.

Dokumentacja MCP PyCharm →

Zed

macOS: ~/.config/zed/settings.json
Windows: %AppData%\Zed\settings.json
Linux: ~/.config/zed/settings.json

Dodaj do ustawień Zed (~/.config/zed/settings.json):

settings.json 
{
  "context_servers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w Zed →

Dokumentacja MCP Zed →

Trae

Włącz Enable Project MCP w Settings → MCP, a potem dodaj do .trae/mcp.json w katalogu głównym projektu:

.trae/mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Dokumentacja MCP Trae →

OpenCode

Dodaj do opencode.json w katalogu głównym swojego projektu:

opencode.json 
{
  "mcp": {
    "maguyva": {
      "type": "remote",
      "url": "https://maguyva.tools/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer {env:MAGUYVA_API_KEY}"
      }
    }
  }
}

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Co Maguyva daje w OpenCode →

Dokumentacja MCP OpenCode →

BoltAI

macOS: ~/.boltai/mcp.json

Dodaj do konfiguracji MCP w BoltAI:

mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "@maguyva/mcp"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Ta konfiguracja korzysta z mostka @maguyva/mcp (wymaga Node.js / npx). Konfiguracja natywnego połączenia zdalnego dla tego klienta nie została zweryfikowana na potrzeby tego przewodnika; nie oznacza to, że klient nie obsługuje natywnych połączeń zdalnych. Maguyva działa całkowicie zdalnie — lokalnie działa tylko mostek.

Dokumentacja MCP BoltAI →

LibreChat

Dodaj do librechat.yaml i ustaw MAGUYVA_API_KEY w środowisku serwera LibreChat:

librechat.yaml 
mcpServers:
  maguyva:
    type: streamable-http
    url: https://maguyva.tools/mcp
    headers:
      Authorization: Bearer ${MAGUYVA_API_KEY}
    requiresOAuth: false

Ta konfiguracja odczytuje klucz ze zmiennej środowiskowej MAGUYVA_API_KEY. Ustaw ją na swój klucz API z app.maguyva.ai w środowisku, z którego uruchamia się Twój klient.

Dokumentacja MCP LibreChat →

Antigravity

macOS: ~/.gemini/config/mcp_config.json
Windows: %UserProfile%\.gemini\config\mcp_config.json
Linux: ~/.gemini/config/mcp_config.json

Dodaj do konfiguracji MCP w Antigravity:

mcp_config.json 
{
  "mcpServers": {
    "maguyva": {
      "serverUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w Antigravity →

Dokumentacja MCP Antigravity →

Claude Cowork

Claude Cowork nie ładuje serwerów z claude_desktop_config.json; zdalne serwery osiąga jako niestandardowe konektory. W Customize → Connectors dodaj niestandardowy konektor z URL https://maguyva.tools/mcp, wybierz No sign-in i dodaj nagłówek żądania authorization z wartością Bearer, po której następuje Twój klucz API. Nagłówki żądań są w becie dla ograniczonej liczby organizacji; jeśli okno nie ma sekcji Request headers, Cowork nie może jeszcze uwierzytelnić się w Maguyva. Zobacz dokumentację →

ChatGPT

ChatGPT obsługuje zdalne serwery MCP w planach Business, Enterprise i Edu poprzez Settings → Apps → Create. Wymagany jest zdalny endpoint HTTPS — ChatGPT nie obsługuje lokalnych serwerów stdio. Instrukcje konfiguracji znajdziesz w przewodniku MCP od OpenAI. Zobacz dokumentację →

Warp

Dodaj do ~/.warp/.mcp.json (lub .warp/.mcp.json w projekcie) albo wklej w Settings → Agents → MCP servers → + Add:

~/.warp/.mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}

Zastąp mgv_xxxx swoim kluczem API z app.maguyva.ai.

Co Maguyva daje w Warp →

Dokumentacja MCP Warp →

Maguyva korzysta ze standardowego MCP. Może się połączyć każdy klient obsługujący ten protokół — nawet jeśli powyżej nie ma dla niego oficjalnego przewodnika. Udokumentowano 23 klientów, a kolejne są regularnie dodawane.

Zweryfikuj swoją konfigurację

#

Po połączeniu spróbuj zadać swojemu agentowi kilka pytań:

  • "Jakie repozytoria mam połączone?" — sprawdza, czy połączenie działa
  • "Jak obsługiwane jest uwierzytelnianie w tym kodzie?" — testuje wyszukiwanie semantyczne
  • "Znajdź wszystkie funkcje, które wywołują bazę danych" — testuje wyszukiwanie zależności
  • "Od czego zależy klasa UserService?" — testuje wyszukiwanie symboli

Powinieneś zobaczyć wyniki ze ścieżkami plików i numerami linii z połączonego repozytorium. Jeśli nie, sprawdź troubleshooting section poniżej.

Format repozytorium

#

Przy określaniu repozytoriów:

  • Z gałęzią: "owner/repo:branch" (e.g., "owner/repository:develop")
  • Domyślna gałąź: "owner/repo"

Wskazówka: sprawdź rozpoznawanie repozytorium za pomocą repository_context(action="info", repository="..."). Nadpisanie repozytorium dotyczy tylko bieżącego wywołania.

Rozwiązywanie problemów

#

Problemy z kluczem API

#
  • Sprawdź, czy klucz zaczyna się od przedrostka mgv_
  • Sprawdź, czy klucz jest poprawnie ustawiony w Twoim środowisku
  • Upewnij się, że klucz nie wygasł

Nie znaleziono repozytorium

#
  • Sprawdź, czy repozytorium jest połączone w app.maguyva.ai
  • Sprawdź, czy format owner/repo jest poprawny
  • Upewnij się, że masz dostęp do repozytorium

Problemy z połączeniem MCP

#
  • Jeśli klient używa mostu @maguyva/mcp, sprawdź, czy npx jest dostępne w PATH
  • Sprawdź, czy Twój token API jest ważny i nie wygasł
  • Przetestuj połączenie z https://maguyva.tools/mcp
  • Sprawdź składnię konfiguracji MCP Twojego klienta

Kolejne kroki

#

Powiązane

Czytaj dalej