de en es ko zh

gitlab-api

Name: gitlab-api
Author: Knuckles-Team

by Knuckles-Team

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

Gitlab Api

CLI oder API | MCP | Agent

PyPI - Version MCP Server PyPI - Downloads GitHub Repo stars GitHub forks GitHub contributors PyPI - License GitHub GitHub last commit (by committer) GitHub pull requests GitHub closed pull requests GitHub issues GitHub top language GitHub language count GitHub repo size GitHub repo file count (file type) PyPI - Wheel PyPI - Implementation

Version: 27.1.0

Dokumentation — Installation, Bereitstellung, Nutzung über die API-, CLI- und MCP-Schnittstellen, der integrierte A2A-Agent-Server sowie Anleitungen zur Bereitstellung der zugrunde liegenden GitLab-Instanz sind in der offiziellen Dokumentation zu finden.

Related MCP server: Kepler MCP GitLab Server

Überblick

Gitlab Api ist ein produktionsreifer Agent- und Model-Context-Protocol-Server (MCP), der für die direkte Anbindung an GitLab API + MCP Server + A2A Server entwickelt wurde.

Kernfunktionen

Konsolidierte aktionsgesteuerte MCP-Tools: Minimiert den Token-Overhead und beseitigt Tool-Aufblähung in LLM-Kontexten, indem Methoden in optimierte, umschaltbare Tool-Module gruppiert werden.
Sicherheit auf Unternehmensniveau: Umfassende Unterstützung für Eunomia-Richtlinien, OIDC-Tokendelegation und granulare Verfolgung des Ausführungskontexts.
Integrierter Graph-Agent: Integrierter Pydantic-AI-Agent, der das Agent Control Protocol (ACP) und Standard-Web-Schnittstellen (AG-UI) unterstützt.
Native Telemetrie & Tracing: OpenTelemetry-Exporte sofort einsatzbereit und natives Langfuse-Tracing.

CLI oder API

Dieser Agent kapselt die GitLab API + MCP Server + A2A Server API. Sie können ihn programmatisch oder über seine integrierten Ausführungs-Einstiegspunkte ansprechen.

Detaillierte Anweisungen zur Verwendung der zugrunde liegenden API-Wrapper, erweiterten Schema-Bindungen und Entwickler-SDK-Referenzen finden Sie in docs/index.md.

MCP

Dieser Server verwendet dynamische aktionsgesteuerte Tools, um den Token-Overhead zu optimieren und die IDE-Kompatibilität zu maximieren.

Tool-Oberfläche — `MCP_TOOL_MODE`

Setzen Sie MCP_TOOL_MODE (in der gemeinsamen ~/.config/agent-utilities/config.json oder als Umgebungsvariable): condensed (Standard — die unten aufgeführten aktionsgesteuerten Tools), verbose (ein benanntes 1:1-Tool pro API-Methode, z. B. gitlab_get_branches(...), markiert mit verbose), oder both. Filtern Sie die verbose-Menge mit --tools tag:verbose / MCP_ENABLED_TAGS=verbose. Siehe den MCP Tool Modes-Leitfaden von agent-utilities.

Verfügbare MCP-Tools

Automatisch vom Live-MCP-Server generiert — nicht von Hand bearbeiten.

Kompakte aktionsgesteuerte Tools (Standard — `MCP_TOOL_MODE=condensed`)

MCP-Tool	Umschalt-Env-Var	Beschreibung
`api_request`	`CUSTOM_APITOOL`	Beliebige GitLab-REST-API-Anfragen direkt ausführen.
`gitlab_branches`	`BRANCHESTOOL`	Operationen für gitlab-Branches verwalten.
`gitlab_commits`	`COMMITSTOOL`	Operationen für gitlab-Commits verwalten.
`gitlab_deploy_tokens`	`DEPLOY_TOKENSTOOL`	Operationen für gitlab-Deploy-Tokens verwalten.
`gitlab_discover_graphql_schema`	`GRAPHQLTOOL`	Das dynamische GitLab-GraphQL-Schema einschließlich Typen, Feldern und benutzerdefinierten Attributen in Echtzeit entdecken.
`gitlab_environments`	`ENVIRONMENTSTOOL`	Operationen für gitlab-Umgebungen verwalten.
`gitlab_epics`	`EPICSTOOL`	GitLab-Epics verwalten.
`gitlab_graphql`	`GRAPHQLTOOL`	Rohe GraphQL-Abfragen und -Mutationen nativ auf GitLab ausführen.
`gitlab_graphql_ops`	`GRAPHQL_OPSTOOL`	Eine typisierte GitLab-GraphQL-Operation anhand des Namens ausführen.
`gitlab_groups`	`GROUPSTOOL`	Operationen für gitlab-Gruppen verwalten.
`gitlab_ingest_pipelines`	`MISCTOOL`	GitLab-CI-Pipeline-Läufe (+ Jobs) nativ in epistemic-graph aufnehmen.
`gitlab_ingest_projects`	`MISCTOOL`	GitLab-Projekte nativ als typisierte :Project-Knoten in epistemic-graph aufnehmen.
`gitlab_instances`	`MISCTOOL`	Die konfigurierten GitLab-Mandanten auflisten (CONCEPT:AU-KG.backend.declared-columns-so-schema).
`gitlab_issues`	`ISSUESTOOL`	GitLab-Issues verwalten.
`gitlab_jobs`	`JOBSTOOL`	Operationen für gitlab-Jobs verwalten.
`gitlab_labels`	`LABELSTOOL`	GitLab-Labels verwalten.
`gitlab_members`	`MEMBERSTOOL`	Operationen für gitlab-Mitglieder verwalten.
`gitlab_merge_requests`	`MERGE_REQUESTSTOOL`	Operationen für gitlab-Merge-Requests verwalten.
`gitlab_merge_rules`	`MERGE_RULESTOOL`	Operationen für gitlab-Merge-Regeln verwalten.
`gitlab_milestones`	`MILESTONESTOOL`	GitLab-Meilensteine verwalten.
`gitlab_namespaces`	`NAMESPACESTOOL`	Operationen für gitlab-Namespaces verwalten.
`gitlab_notes`	`NOTESTOOL`	GitLab-Notizen/Kommentare zu Issues, Merge Requests, Commits und Epics verwalten.
`gitlab_packages`	`PACKAGESTOOL`	Operationen für gitlab-Pakete verwalten.
`gitlab_pipeline_schedules`	`PIPELINE_SCHEDULESTOOL`	Operationen für gitlab-Pipeline-Zeitpläne verwalten.
`gitlab_pipelines`	`PIPELINESTOOL`	Operationen für gitlab-Pipelines verwalten.
`gitlab_projects`	`PROJECTSTOOL`	Operationen für gitlab-Projekte verwalten.
`gitlab_protected_branches`	`PROTECTED_BRANCHESTOOL`	Operationen für geschützte gitlab-Branches verwalten.
`gitlab_releases`	`RELEASESTOOL`	Operationen für gitlab-Releases verwalten.
`gitlab_runners`	`RUNNERSTOOL`	Operationen für gitlab-Runner verwalten.
`gitlab_snippets`	`SNIPPETSTOOL`	GitLab-Snippets verwalten.
`gitlab_tags`	`TAGSTOOL`	Operationen für gitlab-Tags verwalten.
`gitlab_users`	`USERSTOOL`	Operationen für gitlab-Benutzer verwalten.
`gitlab_vulnerabilities`	`VULNERABILITIESTOOL`	Die Abhängigkeitsliste und Sicherheitslücken eines Projekts überprüfen (das GitLab-Pendant zu GitHub Dependabot).
`gitlab_wiki`	`WIKITOOL`	Operationen für gitlab-Wikis verwalten.

Verbose 1:1-API-zugeordnete Tools (`MCP_TOOL_MODE=verbose` oder `both`)

MCP-Tool	Umschalt-Env-Var	Beschreibung
`gitlab_accept_merge_request`	`MERGE_REQUESTSTOOL`	Merge-Request akzeptieren (zusammenführen).
`gitlab_api_request`	`SYSTEMTOOL`	Eine benutzerdefinierte API-Anfrage an den GitLab-Server senden.
`gitlab_approve_merge_request`	`MERGE_REQUESTSTOOL`	Einen bestimmten Merge-Request genehmigen.
`gitlab_archive_project`	`PROJECTSTOOL`	Ein bestimmtes Projekt archivieren.
`gitlab_cancel_merge_when_pipeline_succeeds`	`MERGE_REQUESTSTOOL`	Den geplanten „Merge when pipeline succeeds“ (Auto-Merge) eines Merge-Requests abbrechen.
`gitlab_cancel_project_job`	`PROJECTSTOOL`	Einen bestimmten Job in einem Projekt abbrechen.
`gitlab_cherry_pick_commit`	`REPOSITORIESTOOL`	Einen Commit in einen neuen Branch cherry-picken.
`gitlab_create_branch`	`REPOSITORIESTOOL`	Einen neuen Branch in einem Projekt erstellen.
`gitlab_create_commit`	`REPOSITORIESTOOL`	Einen neuen Commit erstellen.
`gitlab_create_commit_comment`	`REPOSITORIESTOOL`	Einen Kommentar zu einem Commit erstellen.
`gitlab_create_environment`	`ENVIRONMENTSTOOL`	Eine neue Umgebung für ein Projekt erstellen.
`gitlab_create_epic`	`ISSUESTOOL`	Ein neues Gruppen-Epic erstellen.
`gitlab_create_group_deploy_token`	`USERS_GROUPSTOOL`	Ein Deploy-Token für eine Gruppe erstellen.
`gitlab_create_issue`	`ISSUESTOOL`	Ein neues Issue erstellen.
`gitlab_create_label`	`ISSUESTOOL`	Ein neues Label erstellen.
`gitlab_create_merge_request`	`MERGE_REQUESTSTOOL`	Einen neuen Merge-Request erstellen.
`gitlab_create_milestone`	`ISSUESTOOL`	Einen Projekt-Meilenstein erstellen.
`gitlab_create_note`	`OTHERTOOL`	Eine neue Notiz/einen neuen Kommentar zu einem Issue erstellen.
`gitlab_create_pipeline_schedule`	`PIPELINESTOOL`	Einen Pipeline-Zeitplan für ein bestimmtes Projekt erstellen.
`gitlab_create_pipeline_schedule_variable`	`PIPELINESTOOL`	Eine Variable für einen Pipeline-Zeitplan erstellen.
`gitlab_create_project`	`PROJECTSTOOL`	Ein neues Projekt erstellen.
`gitlab_create_project_deploy_token`	`PROJECTSTOOL`	Ein Deploy-Token für ein Projekt erstellen.
`gitlab_create_project_level_rule`	`PROJECTSTOOL`	Eine neue Genehmigungsregel für Merge-Requests auf Projektebene erstellen.
`gitlab_create_release`	`ENVIRONMENTSTOOL`	Ein neues Release in einem Projekt erstellen.
`gitlab_create_release_evidence`	`ENVIRONMENTSTOOL`	Nachweis für ein Release in einem Projekt erstellen.
`gitlab_create_snippet`	`OTHERTOOL`	Ein Projekt-Snippet oder persönliches Snippet erstellen.
`gitlab_create_tag`	`REPOSITORIESTOOL`	Einen Tag in einem Projekt erstellen.
`gitlab_create_user`	`USERS_GROUPSTOOL`	Einen neuen Benutzer erstellen.
`gitlab_create_wiki_page`	`OTHERTOOL`	Eine neue Wiki-Seite für ein Projekt erstellen.
`gitlab_delete_branch`	`REPOSITORIESTOOL`	Einen Branch in einem Projekt löschen.
`gitlab_delete_environment`	`ENVIRONMENTSTOOL`	Eine Umgebung für ein Projekt löschen.
`gitlab_delete_epic`	`ISSUESTOOL`	Ein Gruppen-Epic löschen.
`gitlab_delete_group_deploy_token`	`USERS_GROUPSTOOL`	Ein Deploy-Token für eine Gruppe löschen.
`gitlab_delete_issue`	`ISSUESTOOL`	Ein Issue löschen.
`gitlab_delete_label`	`ISSUESTOOL`	Ein Label löschen.
`gitlab_delete_merged_branches`	`REPOSITORIESTOOL`	Alle zusammengeführten Branches in einem Projekt löschen.
`gitlab_delete_milestone`	`ISSUESTOOL`	Einen Projekt-Meilenstein löschen.
`gitlab_delete_note`	`OTHERTOOL`	Eine Notiz löschen.
`gitlab_delete_pipeline_schedule`	`PIPELINESTOOL`	Einen Pipeline-Zeitplan für ein bestimmtes Projekt löschen.
`gitlab_delete_pipeline_schedule_variable`	`PIPELINESTOOL`	Eine Variable aus einem Pipeline-Zeitplan löschen.
`gitlab_delete_project`	`PROJECTSTOOL`	Ein bestimmtes Projekt löschen.
`gitlab_delete_project_deploy_token`	`PROJECTSTOOL`	Ein Deploy-Token für ein Projekt löschen.
`gitlab_delete_project_level_rule`	`PROJECTSTOOL`	Eine Genehmigungsregel für Merge-Requests auf Projektebene löschen.
`gitlab_delete_project_runner`	`PROJECTSTOOL`	Einen Runner aus einem Projekt löschen.
`gitlab_delete_release`	`ENVIRONMENTSTOOL`	Ein Release in einem Projekt löschen.
`gitlab_delete_runner`	`PIPELINESTOOL`	Einen Runner löschen.
`gitlab_delete_shared_project_link`	`PROJECTSTOOL`	Ein bestimmtes Projekt von einer Gruppe trennen (Freigabe aufheben).
`gitlab_delete_snippet`	`OTHERTOOL`	Ein Snippet löschen.
`gitlab_delete_stopped_environments`	`ENVIRONMENTSTOOL`	Gestoppte Umgebungen (Review-Apps) für ein Projekt löschen.
`gitlab_delete_tag`	`REPOSITORIESTOOL`	Einen Tag in einem Projekt löschen.
`gitlab_delete_user`	`USERS_GROUPSTOOL`	Einen Benutzer löschen.
`gitlab_delete_wiki_page`	`OTHERTOOL`	Eine Wiki-Seite für ein Projekt löschen.
`gitlab_download_release_asset`	`ENVIRONMENTSTOOL`	Ein Release-Asset aus einem Gruppen-Release herunterladen.
`gitlab_download_repository_package`	`OTHERTOOL`	Ein Repository-Paket für ein bestimmtes Projekt herunterladen.
`gitlab_edit_group`	`USERS_GROUPSTOOL`	Eine bestimmte Gruppe bearbeiten.
`gitlab_edit_group_level_rule`	`USERS_GROUPSTOOL`	Eine Genehmigungseinstellung für Merge-Requests auf Gruppenebene bearbeiten.
`gitlab_edit_pipeline_schedule`	`PIPELINESTOOL`	Einen Pipeline-Zeitplan für ein bestimmtes Projekt bearbeiten.
`gitlab_edit_project`	`PROJECTSTOOL`	Ein bestimmtes Projekt bearbeiten.
`gitlab_edit_project_level_rule`	`PROJECTSTOOL`	Eine Genehmigungseinstellung für Merge-Requests auf Projektebene bearbeiten.
`gitlab_enable_project_runner`	`PROJECTSTOOL`	Einen Runner in einem Projekt aktivieren.
`gitlab_erase_project_job`	`PROJECTSTOOL`	Einen bestimmten Job in einem Projekt löschen.
`gitlab_get_approval_state_merge_requests`	`MERGE_REQUESTSTOOL`	Den Genehmigungsstatus von Merge-Requests für ein bestimmtes Projekt abrufen.
`gitlab_get_branch`	`REPOSITORIESTOOL`	Informationen über einen bestimmten Branch in einem Projekt abrufen.
`gitlab_get_branches`	`REPOSITORIESTOOL`	Informationen über Branches in einem Projekt abrufen.
`gitlab_get_commit`	`REPOSITORIESTOOL`	Einen bestimmten Commit abrufen.
`gitlab_get_commit_comments`	`REPOSITORIESTOOL`	Kommentare zu einem Commit abrufen.
`gitlab_get_commit_diff`	`REPOSITORIESTOOL`	Den Diff eines Commits abrufen.
`gitlab_get_commit_discussions`	`REPOSITORIESTOOL`	Diskussionen zu einem Commit abrufen.
`gitlab_get_commit_gpg_signature`	`REPOSITORIESTOOL`	GPG-Signatur eines Commits abrufen.
`gitlab_get_commit_merge_requests`	`REPOSITORIESTOOL`	Mit einem Commit verknüpfte Merge-Requests abrufen.
`gitlab_get_commit_references`	`REPOSITORIESTOOL`	Referenzen eines Commits abrufen.
`gitlab_get_commit_statuses`	`REPOSITORIESTOOL`	Status eines Commits abrufen.
`gitlab_get_commits`	`REPOSITORIESTOOL`	Commits abrufen.
`gitlab_get_deploy_tokens`	`ENVIRONMENTSTOOL`	Alle Deploy-Tokens abrufen.
`gitlab_get_environment`	`ENVIRONMENTSTOOL`	Details einer bestimmten Umgebung abrufen.
`gitlab_get_environments`	`ENVIRONMENTSTOOL`	Eine Liste der Umgebungen für ein Projekt abrufen.
`gitlab_get_epic`	`ISSUESTOOL`	Ein bestimmtes Gruppen-Epic abrufen.
`gitlab_get_epics`	`ISSUESTOOL`	Alle Epics für eine Gruppe abrufen.
`gitlab_get_group`	`USERS_GROUPSTOOL`	Details einer bestimmten Gruppe abrufen.
`gitlab_get_group_deploy_token`	`USERS_GROUPSTOOL`	Ein bestimmtes Deploy-Token für eine Gruppe abrufen.
`gitlab_get_group_deploy_tokens`	`USERS_GROUPSTOOL`	Deploy-Tokens für eine bestimmte Gruppe abrufen.
`gitlab_get_group_descendant_groups`	`USERS_GROUPSTOOL`	Untergruppen einer bestimmten Gruppe abrufen.
`gitlab_get_group_issues`	`ISSUESTOOL`	Die Liste der Issues für eine Gruppe (und standardmäßig deren Untergruppen) abrufen.
`gitlab_get_group_level_rule`	`USERS_GROUPSTOOL`	Details einer Genehmigungseinstellung für Merge-Requests auf Gruppenebene abrufen.
`gitlab_get_group_members`	`USERS_GROUPSTOOL`	Mitglieder einer bestimmten Gruppe abrufen.
`gitlab_get_group_merge_requests`	`MERGE_REQUESTSTOOL`	Mit einer bestimmten Gruppe verknüpfte Merge-Requests abrufen.
`gitlab_get_group_projects`	`PROJECTSTOOL`	Mit einer bestimmten Gruppe verknüpfte Projekte abrufen.
`gitlab_get_group_releases`	`USERS_GROUPSTOOL`	Informationen über Releases in einer Gruppe abrufen.
`gitlab_get_group_runners`	`PIPELINESTOOL`	Informationen über Runner in einer Gruppe abrufen.
`gitlab_get_group_subgroups`	`USERS_GROUPSTOOL`	Untergruppen einer bestimmten Gruppe abrufen.
`gitlab_get_group_vulnerabilities`	`VULNERABILITIESTOOL`	Sicherheitslücken-Ergebnisse einer Gruppe abrufen (Ultimate).
`gitlab_get_groups`	`USERS_GROUPSTOOL`	Eine Liste von Gruppen abrufen.
`gitlab_get_issue`	`ISSUESTOOL`	Ein einzelnes Issue abrufen.
`gitlab_get_issues`	`ISSUESTOOL`	Liste von Issues abrufen. Kann nach project_id filtern.
`gitlab_get_label`	`ISSUESTOOL`	Ein bestimmtes Label nach Namen abrufen.
`gitlab_get_labels`	`ISSUESTOOL`	Alle Labels für ein Projekt abrufen.
`gitlab_get_latest_release`	`ENVIRONMENTSTOOL`	Informationen über das neueste Release in einem Projekt abrufen.
`gitlab_get_latest_release_asset`	`ENVIRONMENTSTOOL`	Das Asset für das neueste Release in einem Projekt abrufen.
`gitlab_get_latest_release_evidence`	`ENVIRONMENTSTOOL`	Nachweis für das neueste Release in einem Projekt abrufen.
`gitlab_get_merge_request_level_rules`	`MERGE_REQUESTSTOOL`	Genehmigungsregeln auf Merge-Request-Ebene für ein bestimmtes Projekt und einen bestimmten Merge-Request abrufen.
`gitlab_get_merge_requests`	`MERGE_REQUESTSTOOL`	Eine Liste von Merge-Requests abrufen.
`gitlab_get_milestone`	`ISSUESTOOL`	Einen bestimmten Projekt-Meilenstein abrufen.
`gitlab_get_milestones`	`ISSUESTOOL`	Alle Meilensteine für ein Projekt abrufen.
`gitlab_get_namespace`	`USERS_GROUPSTOOL`	Informationen über einen bestimmten Namespace abrufen.
`gitlab_get_namespaces`	`USERS_GROUPSTOOL`	Informationen über Namespaces abrufen.
`gitlab_get_nested_projects_by_group`	`PROJECTSTOOL`	Informationen über verschachtelte Projekte innerhalb einer Gruppe abrufen.
`gitlab_get_note`	`OTHERTOOL`	Eine bestimmte Notiz abrufen.
`gitlab_get_notes`	`OTHERTOOL`	Alle Notizen für ein bestimmtes Issue abrufen.
`gitlab_get_pipeline`	`PIPELINESTOOL`	Informationen über eine bestimmte Pipeline in einem Projekt abrufen.
`gitlab_get_pipeline_jobs`	`PIPELINESTOOL`	Jobs abrufen, die mit einer bestimmten Pipeline in einem Projekt verknüpft sind.
`gitlab_get_pipeline_schedule`	`PIPELINESTOOL`	Informationen über einen bestimmten Pipeline-Zeitplan in einem Projekt abrufen.
`gitlab_get_pipeline_schedules`	`PIPELINESTOOL`	Pipeline-Zeitpläne für ein bestimmtes Projekt abrufen.
`gitlab_get_pipelines`	`PIPELINESTOOL`	Informationen über Pipelines für ein bestimmtes Projekt abrufen.
`gitlab_get_pipelines_triggered_from_schedule`	`PIPELINESTOOL`	Pipelines abrufen, die von einem bestimmten Pipeline-Zeitplan ausgelöst wurden.
`gitlab_get_project`	`PROJECTSTOOL`	Informationen über ein bestimmtes Projekt abrufen.
`gitlab_get_project_contributors`	`PROJECTSTOOL`	Informationen über Mitwirkende an einem Projekt abrufen.
`gitlab_get_project_dependencies`	`VULNERABILITIESTOOL`	Die Abhängigkeitsliste eines Projekts abrufen (alle erkannten Abhängigkeiten).
`gitlab_get_project_deploy_token`	`PROJECTSTOOL`	Ein bestimmtes Deploy-Token für ein Projekt abrufen.
`gitlab_get_project_deploy_tokens`	`PROJECTSTOOL`	Deploy-Tokens für ein bestimmtes Projekt abrufen.
`gitlab_get_project_groups`	`PROJECTSTOOL`	Mit einem bestimmten Projekt verknüpfte Gruppen abrufen.
`gitlab_get_project_job`	`PROJECTSTOOL`	Details eines bestimmten Jobs in einem Projekt abrufen.
`gitlab_get_project_job_log`	`PROJECTSTOOL`	Das Protokoll eines bestimmten Jobs in einem Projekt abrufen.
`gitlab_get_project_jobs`	`PROJECTSTOOL`	Jobs abrufen, die mit einem bestimmten Projekt verknüpft sind.
`gitlab_get_project_level_merge_request_rule`	`PROJECTSTOOL`	Details einer bestimmten Genehmigungsregel für Merge-Requests auf Projektebene abrufen.
`gitlab_get_project_level_merge_request_rules`	`PROJECTSTOOL`	Genehmigungsregeln für Merge-Requests auf Projektebene abrufen.
`gitlab_get_project_level_rule`	`PROJECTSTOOL`	Details einer Genehmigungseinstellung für Merge-Requests auf Projektebene abrufen.
`gitlab_get_project_members`	`PROJECTSTOOL`	Mitglieder eines bestimmten Projekts abrufen.
`gitlab_get_project_merge_request`	`PROJECTSTOOL`	Details eines bestimmten Merge-Requests in einem Projekt abrufen.
`gitlab_get_project_merge_requests`	`PROJECTSTOOL`	Merge-Requests für ein bestimmtes Projekt abrufen.
`gitlab_get_project_runners`	`PROJECTSTOOL`	Informationen über Runner in einem Projekt abrufen.
`gitlab_get_project_statistics`	`PROJECTSTOOL`	Statistiken für ein bestimmtes Projekt abrufen.
`gitlab_get_project_vulnerabilities`	`VULNERABILITIESTOOL`	Sicherheitslücken eines Projekts abrufen (Ultimate).
`gitlab_get_projects`	`PROJECTSTOOL`	Informationen über Projekte abrufen.
`gitlab_get_protected_branch`	`REPOSITORIESTOOL`	Informationen über einen bestimmten geschützten Branch in einem Projekt abrufen.
`gitlab_get_protected_branches`	`REPOSITORIESTOOL`	Informationen über geschützte Branches in einem Projekt abrufen.
`gitlab_get_protected_environment`	`ENVIRONMENTSTOOL`	Details einer bestimmten geschützten Umgebung abrufen.
`gitlab_get_protected_environments`	`ENVIRONMENTSTOOL`	Eine Liste der geschützten Umgebungen für ein Projekt abrufen.
`gitlab_get_protected_tag`	`REPOSITORIESTOOL`	Informationen über einen bestimmten geschützten Tag in einem Projekt abrufen.
`gitlab_get_protected_tags`	`REPOSITORIESTOOL`	Informationen über geschützte Tags in einem Projekt abrufen.
`gitlab_get_release_by_tag`	`REPOSITORIESTOOL`	Informationen über ein Release anhand seines Tags in einem Projekt abrufen.
`gitlab_get_releases`	`ENVIRONMENTSTOOL`	Informationen über Releases in einem Projekt abrufen.
`gitlab_get_repository_packages`	`OTHERTOOL`	Informationen über Repository-Pakete für ein bestimmtes Projekt abrufen.
`gitlab_get_runner`	`PIPELINESTOOL`	Informationen über einen bestimmten Runner abrufen.
`gitlab_get_runner_jobs`	`PIPELINESTOOL`	Jobs für einen bestimmten Runner abrufen.
`gitlab_get_runners`	`PIPELINESTOOL`	Informationen über Runner abrufen.
`gitlab_get_snippet`	`OTHERTOOL`	Ein bestimmtes Snippet abrufen.
`gitlab_get_snippets`	`OTHERTOOL`	Liste von Snippets abrufen. Kann nach project_id filtern.
`gitlab_get_tag`	`REPOSITORIESTOOL`	Informationen über einen bestimmten Tag in einem Projekt abrufen.
`gitlab_get_tags`	`REPOSITORIESTOOL`	Informationen über Tags in einem Projekt abrufen.
`gitlab_get_user`	`USERS_GROUPSTOOL`	Informationen über einen bestimmten Benutzer abrufen.
`gitlab_get_users`	`USERS_GROUPSTOOL`	Informationen über Benutzer abrufen.
`gitlab_get_vulnerability`	`VULNERABILITIESTOOL`	Eine einzelne Sicherheitslücke anhand ihrer globalen ID abrufen (Ultimate).
`gitlab_get_wiki_list`	`OTHERTOOL`	Eine Liste der Wiki-Seiten für ein Projekt abrufen.
`gitlab_get_wiki_page`	`OTHERTOOL`	Informationen über eine bestimmte Wiki-Seite abrufen.
`gitlab_merge_request_level_approvals`	`MERGE_REQUESTSTOOL`	Genehmigungen für einen bestimmten Merge-Request abrufen.
`gitlab_pause_runner`	`PIPELINESTOOL`	Einen bestimmten Runner pausieren oder reaktivieren.
`gitlab_post_build_status_to_commit`	`REPOSITORIESTOOL`	Build-Status an einen Commit senden.
`gitlab_protect_branch`	`REPOSITORIESTOOL`	Einen bestimmten Branch in einem Projekt schützen.
`gitlab_protect_environment`	`ENVIRONMENTSTOOL`	Eine Umgebung für ein Projekt schützen.
`gitlab_protect_tag`	`REPOSITORIESTOOL`	Einen Tag in einem Projekt schützen.
`gitlab_publish_repository_package`	`OTHERTOOL`	Ein Repository-Paket für ein bestimmtes Projekt veröffentlichen.
`gitlab_register_new_runner`	`PIPELINESTOOL`	Einen neuen Runner registrieren.
`gitlab_require_code_owner_approvals_single_branch`	`REPOSITORIESTOOL`	Code-Owner-Genehmigungen für einen bestimmten Branch in einem Projekt anfordern.
`gitlab_reset_gitlab_runner_token`	`PIPELINESTOOL`	GitLab-Runner-Registrierungstoken zurücksetzen.
`gitlab_reset_group_runner_token`	`PIPELINESTOOL`	Registrierungstoken für den Runner einer Gruppe zurücksetzen.
`gitlab_reset_project_runner_token`	`PROJECTSTOOL`	Registrierungstoken für den Runner eines Projekts zurücksetzen.
`gitlab_reset_token`	`OTHERTOOL`	Authentifizierungstoken für einen Runner zurücksetzen.
`gitlab_retry_project_job`	`PROJECTSTOOL`	Einen bestimmten Job in einem Projekt erneut versuchen.
`gitlab_revert_commit`	`REPOSITORIESTOOL`	Einen Commit zurücknehmen (revertieren).
`gitlab_run_pipeline`	`PIPELINESTOOL`	Eine Pipeline für ein bestimmtes Projekt ausführen.
`gitlab_run_pipeline_schedule`	`PIPELINESTOOL`	Einen Pipeline-Zeitplan für ein bestimmtes Projekt ausführen.
`gitlab_run_project_job`	`PROJECTSTOOL`	Einen bestimmten Job in einem Projekt ausführen.
`gitlab_share_project`	`PROJECTSTOOL`	Ein bestimmtes Projekt mit einer Gruppe teilen.
`gitlab_stop_environment`	`ENVIRONMENTSTOOL`	Eine Umgebung für ein Projekt stoppen.
`gitlab_stop_stale_environments`	`ENVIRONMENTSTOOL`	Veraltete Umgebungen für ein Projekt stoppen.
`gitlab_take_pipeline_schedule_ownership`	`PIPELINESTOOL`	Besitz eines Pipeline-Zeitplans für ein bestimmtes Projekt übernehmen.
`gitlab_unapprove_merge_request`	`MERGE_REQUESTSTOOL`	Die Genehmigung eines bestimmten Merge-Requests zurückziehen.
`gitlab_unarchive_project`	`PROJECTSTOOL`	Ein bestimmtes Projekt aus dem Archiv holen (reaktivieren).
`gitlab_unprotect_branch`	`REPOSITORIESTOOL`	Den Schutz eines bestimmten Branchs in einem Projekt aufheben.
`gitlab_unprotect_environment`	`ENVIRONMENTSTOOL`	Den Schutz einer Umgebung für ein Projekt aufheben.
`gitlab_unprotect_tag`	`REPOSITORIESTOOL`	Den Schutz eines Tags in einem Projekt aufheben.
`gitlab_update_environment`	`ENVIRONMENTSTOOL`	Eine vorhandene Umgebung für ein Projekt aktualisieren.
`gitlab_update_epic`	`ISSUESTOOL`	Ein Gruppen-Epic aktualisieren.
`gitlab_update_issue`	`ISSUESTOOL`	Ein Issue aktualisieren.
`gitlab_update_label`	`ISSUESTOOL`	Ein vorhandenes Label aktualisieren.
`gitlab_update_milestone`	`ISSUESTOOL`	Einen Projekt-Meilenstein aktualisieren.
`gitlab_update_note`	`OTHERTOOL`	Eine Notiz aktualisieren.
`gitlab_update_project_level_rule`	`PROJECTSTOOL`	Eine vorhandene Genehmigungsregel für Merge-Requests auf Projektebene aktualisieren.
`gitlab_update_protected_environment`	`ENVIRONMENTSTOOL`	Eine geschützte Umgebung für ein Projekt aktualisieren.
`gitlab_update_release`	`ENVIRONMENTSTOOL`	Informationen über ein Release in einem Projekt aktualisieren.
`gitlab_update_runner_details`	`PIPELINESTOOL`	Details für einen bestimmten Runner aktualisieren.
`gitlab_update_snippet`	`OTHERTOOL`	Ein Snippet aktualisieren.
`gitlab_update_user`	`USERS_GROUPSTOOL`	Einen vorhandenen Benutzer aktualisieren.
`gitlab_update_wiki_page`	`OTHERTOOL`	Eine vorhandene Wiki-Seite für ein Projekt aktualisieren.
`gitlab_upload_wiki_page_attachment`	`OTHERTOOL`	Einen Anhang zu einer Wiki-Seite für ein Projekt hochladen.
`gitlab_verify_runner_authentication`	`PIPELINESTOOL`	Runner-Authentifizierung überprüfen.

34 aktionsgeroutete Tool(s) (Standard) · 196 verbose 1:1-Tool(s). Jedes ist aktiviert, sofern sein <DOMAIN>TOOL-Schalter nicht auf false gesetzt ist; MCP_TOOL_MODE wählt die Oberfläche (condensed Standard · verbose 1:1 · both). Automatisch generiert — nicht bearbeiten.

Detaillierte Tool-Schemas, Parameterstrukturen und Validierungsbeschränkungen sind in docs/usage.md dokumentiert.

Dynamische Tool-Auswahl und Sichtbarkeit

Dieser MCP-Server unterstützt die dynamische Auswahl von Tool-Sets und die Sichtbarkeitsfilterung zur Laufzeit. Dadurch können Sie die Menge der bereitgestellten Tools einschränken, um ein Aufblähen des Kontextfensters des LLM zu verhindern.

Sie können die Tool-Filterung über mehrere Eingabekanäle konfigurieren:

CLI-Argumente: Übergeben Sie --tools oder --toolsets (oder deren deaktivierte Gegenstücke --disabled-tools und --disabled-toolsets) beim Start.
Umgebungsvariablen: Definieren Sie Standard-Umgebungsvariablen:
- MCP_ENABLED_TOOLS / MCP_DISABLED_TOOLS
- MCP_ENABLED_TAGS / MCP_DISABLED_TAGS
HTTP-SSE-Anfrageheader: Übergeben Sie während der Transportinitialisierung benutzerdefinierte Header:
- x-mcp-enabled-tools / x-mcp-disabled-tools
- x-mcp-enabled-tags / x-mcp-disabled-tags
HTTP-SSE-Anfrage-Query-Parameter: Fügen Sie Query-Parameter direkt an Ihre Transportverbindungs-URL an:
- ?tools=tool1,tool2
- ?tags=tag1

Wenn Query-Strings oder -Parameter angegeben werden, gleicht eine LLM-freie Knowledge-Graph-Auflösungsebene (unter Verwendung von DynamicToolOrchestrator) die Abfrageintentionen mit bekannten Tool-Tags, -Namen oder -Beschreibungen ab, mit sicherem Fallback und automatischer 24-stündiger Hintergrundaktualisierung des Caches.

MCP-Konfigurationsbeispiele

Installieren Sie das connector-fokussierte Zusatzpaket [mcp]. Die Beispiele verwenden gitlab-api[mcp], um FastMCP / FastAPI über agent-utilities[mcp] hinzuzufügen; der erforderliche Agent-Utilities-Kern enthält weiterhin epistemic-graph[full]. Das Zusatzpaket [agent-runtime] aktiviert zusätzlich die Modell-Orchestrierung.

stdio-Transport (lokale IDEs — Cursor, Claude Desktop, VS Code)

{
  "mcpServers": {
    "gitlab-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "gitlab-api[mcp]",
        "gitlab-mcp"
      ],
      "env": {
        "MCP_TOOL_MODE": "intent",
        "BRANCHESTOOL": "True",
        "COMMITSTOOL": "True",
        "CUSTOM_APITOOL": "True",
        "DEPLOY_TOKENSTOOL": "True",
        "ENVIRONMENTSTOOL": "True",
        "EPICSTOOL": "True",
        "GITLAB_TOKEN": "your_gitlab_token_here",
        "GITLAB_URL": "https://gitlab.example.com",
        "GRAPHQLTOOL": "True",
        "GRAPHQL_OPSTOOL": "True",
        "GROUPSTOOL": "True",
        "ISSUESTOOL": "True",
        "JOBSTOOL": "True",
        "LABELSTOOL": "True",
        "MEMBERSTOOL": "True",
        "MERGE_REQUESTSTOOL": "True",
        "MERGE_RULESTOOL": "True",
        "MILESTONESTOOL": "True",
        "MISCTOOL": "True",
        "NAMESPACESTOOL": "True",
        "NOTESTOOL": "True",
        "PACKAGESTOOL": "True",
        "PIPELINESTOOL": "True",
        "PIPELINE_SCHEDULESTOOL": "True",
        "PROJECTSTOOL": "True",
        "PROTECTED_BRANCHESTOOL": "True",
        "RELEASESTOOL": "True",
        "RUNNERSTOOL": "True",
        "SNIPPETSTOOL": "True",
        "TAGSTOOL": "True",
        "USERSTOOL": "True",
        "VULNERABILITIESTOOL": "True",
        "WIKITOOL": "True"
      }
    }
  }
}

Laufzeitreferenzen erfordern einen alias-fähigen Launcher wie GraphOS. Andere Launcher müssen diese Einträge weglassen und die aufgelösten Werte über ihre eigene Laufzeit-Geheimnisgrenze injizieren.

Streamable-HTTP-Transport (netzwerkbasiert / Produktion)

{
  "mcpServers": {
    "gitlab-mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "gitlab-api[mcp]",
        "gitlab-mcp",
        "--transport",
        "streamable-http",
        "--port",
        "8000"
      ],
      "env": {
        "TRANSPORT": "streamable-http",
        "HOST": "127.0.0.1",
        "PORT": "8000",
        "MCP_TOOL_MODE": "intent",
        "BRANCHESTOOL": "True",
        "COMMITSTOOL": "True",
        "CUSTOM_APITOOL": "True",
        "DEPLOY_TOKENSTOOL": "True",
        "ENVIRONMENTSTOOL": "True",
        "EPICSTOOL": "True",
        "GITLAB_TOKEN": "your_gitlab_token_here",
        "GITLAB_URL": "https://gitlab.example.com",
        "GRAPHQLTOOL": "True",
        "GRAPHQL_OPSTOOL": "True",
        "GROUPSTOOL": "True",
        "ISSUESTOOL": "True",
        "JOBSTOOL": "True",
        "LABELSTOOL": "True",
        "MEMBERSTOOL": "True",
        "MERGE_REQUESTSTOOL": "True",
        "MERGE_RULESTOOL": "True",
        "MILESTONESTOOL": "True",
        "MISCTOOL": "True",
        "NAMESPACESTOOL": "True",
        "NOTESTOOL": "True",
        "PACKAGESTOOL": "True",
        "PIPELINESTOOL": "True",
        "PIPELINE_SCHEDULESTOOL": "True",
        "PROJECTSTOOL": "True",
        "PROTECTED_BRANCHESTOOL": "True",
        "RELEASESTOOL": "True",
        "RUNNERSTOOL": "True",
        "SNIPPETSTOOL": "True",
        "TAGSTOOL": "True",
        "USERSTOOL": "True",
        "VULNERABILITIESTOOL": "True",
        "WIKITOOL": "True"
      }
    }
  }
}

Alternativ können Sie über url eine Verbindung zu einer bereits bereitgestellten Streamable-HTTP-Instanz herstellen:

{
  "mcpServers": {
    "gitlab-mcp": {
      "url": "http://localhost:8000/gitlab-mcp/mcp"
    }
  }
}

Führen Sie ein geprüftes Container-Image als stdio-Kindprozess mit minimalen Rechten aus (kein Listener oder veröffentlichter Port):

docker run -i --rm \
  --read-only \
  --cap-drop=ALL \
  --security-opt=no-new-privileges \
  --pids-limit=256 \
  --tmpfs /tmp:rw,noexec,nosuid,nodev,size=64m \
  -e TRANSPORT=stdio \
  -e MCP_TOOL_MODE=intent \
  -e BRANCHESTOOL=True \
  -e COMMITSTOOL=True \
  -e CUSTOM_APITOOL=True \
  -e DEPLOY_TOKENSTOOL=True \
  -e ENVIRONMENTSTOOL=True \
  -e EPICSTOOL=True \
  -e GITLAB_TOKEN=your_gitlab_token_here \
  -e GITLAB_URL=https://gitlab.example.com \
  -e GRAPHQLTOOL=True \
  -e GRAPHQL_OPSTOOL=True \
  -e GROUPSTOOL=True \
  -e ISSUESTOOL=True \
  -e JOBSTOOL=True \
  -e LABELSTOOL=True \
  -e MEMBERSTOOL=True \
  -e MERGE_REQUESTSTOOL=True \
  -e MERGE_RULESTOOL=True \
  -e MILESTONESTOOL=True \
  -e MISCTOOL=True \
  -e NAMESPACESTOOL=True \
  -e NOTESTOOL=True \
  -e PACKAGESTOOL=True \
  -e PIPELINESTOOL=True \
  -e PIPELINE_SCHEDULESTOOL=True \
  -e PROJECTSTOOL=True \
  -e PROTECTED_BRANCHESTOOL=True \
  -e RELEASESTOOL=True \
  -e RUNNERSTOOL=True \
  -e SNIPPETSTOOL=True \
  -e TAGSTOOL=True \
  -e USERSTOOL=True \
  -e VULNERABILITIESTOOL=True \
  -e WIKITOOL=True \
  registry.example.invalid/gitlab-api@sha256:<digest> gitlab-mcp

Für containerisierten Netzwerk-HTTP stellen Sie einen authentifizierten TLS-Ingress (oder direktes Server-TLS), exakte MCP_ALLOWED_HOSTS und eine exakte Trusted-Proxy- CIDR-Richtlinie über das vom Betreiber verwaltete Bereitstellungsprofil bereit. Der Generator erzeugt keinen unauthentifizierten Non-Loopback-Listener.

Automatisch aus der per Code ausgelesenen Env-Oberfläche generiert (MCP_TOOL_MODE + Paketvariablen) — nicht bearbeiten.

Zusätzliche Bereitstellungsoptionen

gitlab-api kann als lokaler stdio-Prozess oder Container oder hinter einer entfernten Netzwerkgrenze ausgeführt werden. Die Bereitstellungsanleitung enthält den detaillierten Transportvertrag.

Lokaler Container — starten Sie ein geprüftes unveränderliches Image als stdio-Kindprozess mit minimalen Rechten ohne Listener oder veröffentlichten Port.
Remote-URL — verbinden Sie sich über einen vom Betreiber bereitgestellten authentifizierten HTTPS- Ingress. Bewahren Sie dessen URL, ausgehende Identitätsreferenzen, Vertrauensprofil und die exakten MCP_ALLOWED_HOSTS in AgentConfig auf.

Umgebungsvariablen

Paket-Umgebungsvariablen

Variable	Beispiel	Beschreibung
`HOST`	`0.0.0.0`
`PORT`	`8000`
`TRANSPORT`	`stdio`	Optionen: stdio, streamable-http, sse
`ENABLE_OTEL`	`True`
`OTEL_EXPORTER_OTLP_ENDPOINT`	`http://localhost:8080/api/public/otel`
`OTEL_EXPORTER_OTLP_PUBLIC_KEY`	secret-injected
`OTEL_EXPORTER_OTLP_SECRET_KEY`	secret-injected
`OTEL_EXPORTER_OTLP_PROTOCOL`	`http/protobuf`
`EUNOMIA_TYPE`	`none`	Optionen: none, embedded, remote
`EUNOMIA_POLICY_FILE`	`mcp_policies.json`
`EUNOMIA_REMOTE_URL`	`http://eunomia-server:8000`
`GITLAB_URL`	`https://gitlab.example.com`
`GITLAB_TOKEN`	secret-injected
`GITLAB_TLS_PROFILE`	—	benanntes AgentConfig-TLS-Profil; leer verwendet das konfigurierte Standardprofil
`MISCTOOL`	`True`
`BRANCHESTOOL`	`True`
`PROTECTED_BRANCHESTOOL`	`True`
`COMMITSTOOL`	`True`
`DEPLOY_TOKENSTOOL`	`True`
`ENVIRONMENTSTOOL`	`True`
`EPICSTOOL`	`True`
`GROUPSTOOL`	`True`
`ISSUESTOOL`	`True`
`JOBSTOOL`	`True`
`LABELSTOOL`	`True`
`MEMBERSTOOL`	`True`
`MERGE_REQUESTSTOOL`	`True`
`MERGE_RULESTOOL`	`True`
`MILESTONESTOOL`	`True`
`NAMESPACESTOOL`	`True`
`NOTESTOOL`	`True`
`PACKAGESTOOL`	`True`
`PIPELINESTOOL`	`True`
`PIPELINE_SCHEDULESTOOL`	`True`
`PROJECTSTOOL`	`True`
`RELEASESTOOL`	`True`
`RUNNERSTOOL`	`True`
`SNIPPETSTOOL`	`True`
`TAGSTOOL`	`True`
`USERSTOOL`	`True`
`VULNERABILITIESTOOL`	`True`
`WIKITOOL`	`True`
`CUSTOM_APITOOL`	`True`
`GRAPHQLTOOL`	`True`
`GRAPHQL_OPSTOOL`	`True`

Geerbte agent-utilities-Variablen (gelten für jeden Connector)

Variable	Beispiel	Beschreibung
`MCP_TOOL_MODE`	`intent`	Tool-Oberfläche: `intent` \| `condensed` \| `verbose` \| `both`
`MCP_ENABLED_TOOLS`	—	Kommagetrennte Tool-Allowlist
`MCP_DISABLED_TOOLS`	—	Kommagetrennte Tool-Denylist
`MCP_ENABLED_TAGS`	—	Kommagetrennte Tag-Allowlist
`MCP_DISABLED_TAGS`	—	Kommagetrennte Tag-Denylist
`MCP_CLIENT_AUTH`	—	Ausgehende MCP-Child-Authentifizierung: `oidc-client-credentials` \| `basic` \| `none`
`OIDC_CLIENT_ID`	—	OIDC-Client-ID (Service-Account-Authentifizierung)
`OIDC_CLIENT_SECRET_REF`	`secret://identity/oidc-client-secret`	Laufzeit-Secret-Referenz für den OIDC-Service-Account
`MCP_BASIC_AUTH_USERNAME`	—	HTTP-Basic-Benutzername (`MCP_CLIENT_AUTH=basic`)
`MCP_BASIC_AUTH_PASSWORD_REF`	`secret://identity/mcp-basic-password`	Laufzeit-Secret-Referenz für HTTP-Basic-Auth (`MCP_CLIENT_AUTH=basic`)
`DEBUG`	`False`	Ausführliche Protokollierung
`PYTHONUNBUFFERED`	`1`	Ungepufferte Standardausgabe (in Containern empfohlen)
`MCP_URL`	`http://localhost:8000/mcp`	URL des MCP-Servers, mit dem der Agent verbunden ist
`PROVIDER`	`openai`	LLM-Anbieter für den Agent
`MODEL_ID`	`gpt-4o`	Modell-ID für den Agent
`ENABLE_WEB_UI`	`True`	AG-UI-Weboberfläche bereitstellen

45 Paket- + 16 geerbte Variable(n). Automatisch generiert aus .env.example + dem gemeinsamen agent-utilities-Satz — nicht bearbeiten.

Jede Variable, die der Server liest.

Verbindung & Anmeldedaten

Der Connector ist standardmäßig Single-Host und multi-tenant, wenn gitlab_instances konfiguriert ist (siehe Multi-Tenancy). Wenn keine Instanzen konfiguriert sind, greift er auf die Single-Host-Werte GITLAB_* unten zurück.

Variable	Beschreibung	Standard
`GITLAB_URL`	Basis-URL der GitLab-Instanz	`https://gitlab.example.com`
`GITLAB_TOKEN`	GitLab-Personal-/Projektzugriffstoken (`glpat-…`)	—
`GITLAB_TLS_PROFILE`	Optionaler Laufzeit-TLS-Profilselektor	(nicht gesetzt)

Mehrere Instanzen werden einmal unter gitlab_instances in der gemeinsamen agent-utilities-XDG-Konfiguration (~/.config/agent-utilities/config.json) deklariert — jeder Eintrag hat name, url, token und optional tls_profile. Zielen Sie von der Client- Factory aus per Name auf einen Mandanten; eine nicht gesetzte Instanz löst zur ersten konfigurierten auf (sonst GITLAB_URL / GITLAB_TOKEN).

MCP-Server / Transport

Variable	Beschreibung	Standard
`TRANSPORT`	`stdio`, `streamable-http` oder `sse`	`stdio`
`HOST`	Bind-Host (HTTP-Transports)	`0.0.0.0`
`PORT`	Bind-Port (HTTP-Transports)	`8000`
`MCP_TOOL_MODE`	Tool-Oberfläche: `condensed`, `verbose` oder `both`	`condensed`
`MCP_ENABLED_TOOLS` / `MCP_DISABLED_TOOLS`	Kommagetrennte Tool-Allow-/Denylist	—
`MCP_ENABLED_TAGS` / `MCP_DISABLED_TAGS`	Kommagetrennte Tag-Allow-/Denylist	—
`DEBUG`	Ausführliche Protokollierung	`False`
`PYTHONUNBUFFERED`	Ungepufferte Standardausgabe (in Containern empfohlen)	`1`

Tool-Umschalter

Jedes aktionsgesteuerte Tool kann einzeln über seine Umschalt-Env-Variable deaktiviert werden (auf false setzen). Die vollständige Liste finden Sie in der Tabelle Verfügbare MCP-Tools oben (z. B. PROJECTSTOOL, MERGE_REQUESTSTOOL, PIPELINESTOOL, GRAPHQLTOOL, CUSTOM_APITOOL).

Telemetrie & Governance

Variable	Beschreibung	Standard
`ENABLE_OTEL`	OpenTelemetry-Export aktivieren	`True`
`OTEL_EXPORTER_OTLP_ENDPOINT`	OTLP-Collector-Endpunkt	—
`OTEL_EXPORTER_OTLP_PUBLIC_KEY` / `OTEL_EXPORTER_OTLP_SECRET_KEY`	OTLP-Auth-Schlüssel	—
`OTEL_EXPORTER_OTLP_PROTOCOL`	OTLP-Protokoll (z. B. `http/protobuf`)	—
`EUNOMIA_TYPE`	Autorisierungsmodus: `none`, `embedded`, `remote`	`none`
`EUNOMIA_POLICY_FILE`	Eingebettete Policy-Datei	`mcp_policies.json`
`EUNOMIA_REMOTE_URL`	Remote-Eunomia-Server-URL	—

Agent-CLI (nur vollständige `[agent]`-Laufzeit)

Variable	Beschreibung	Standard
`MCP_URL`	URL des MCP-Servers, mit dem der Agent verbunden ist	`http://localhost:8000/mcp`
`PROVIDER`	LLM-Anbieter (z. B. `openai`)	`openai`
`MODEL_ID`	Modell-ID (z. B. `gpt-4o`)	`gpt-4o`
`ENABLE_WEB_UI`	AG-UI-Weboberfläche bereitstellen	`True`

Siehe .env.example als Copy-Paste-Ausgangspunkt.

Agent

Dieses Repository enthält einen vollständig integrierten Pydantic-AI-Graph-Agenten. Er kommuniziert über das Agent Control Protocol (ACP) und interagiert nahtlos mit der Agent-Web-UI (AG-UI) und der Terminal-Schnittstelle.

Ausführen der Agent-CLI

So starten Sie den interaktiven Kommandozeilen-Agenten:

# Set credentials
export GITLAB_URL="your_value"
export GITLAB_TOKEN="your_value"

# Run the agent server
gitlab-agent --provider openai --model-id gpt-4o

Docker-Compose-Orchestrierung

Die folgende docker/agent.compose.yml konfiguriert Agent, Web-UI und Terminal-Schnittstelle gemeinsam:

version: '3.8'

services:
  gitlab-api-mcp:
    image: example/gitlab-api:mcp
    container_name: gitlab-api-mcp
    hostname: gitlab-api-mcp
    restart: always
    env_file:
      - ../.env
    environment:
      - PYTHONUNBUFFERED=1
      - HOST=0.0.0.0
      - PORT=8000
      - TRANSPORT=streamable-http
    ports:
      - "8000:8000"
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  gitlab-api-agent:
    image: example/gitlab-api@sha256:<digest>
    container_name: gitlab-api-agent
    hostname: gitlab-api-agent
    restart: always
    depends_on:
      - gitlab-api-mcp
    env_file:
      - ../.env
    command: [ "gitlab-agent" ]
    environment:
      - PYTHONUNBUFFERED=1
      - HOST=0.0.0.0
      - PORT=9017
      - MCP_URL=http://gitlab-api-mcp:8000/mcp
      - PROVIDER=${PROVIDER:-openai}
      - MODEL_ID=${MODEL_ID:-gpt-4o}
      - ENABLE_WEB_UI=True
      - ENABLE_OTEL=True
    ports:
      - "9017:9017"
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:9017/health')"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

Detaillierte Erläuterungen zur Graph-Knotenarchitektur, benutzerdefinierte Skill-Konfigurationen und Anleitungen zu agentischen Traces finden Sie in docs/deployment.md.

Multi-Tenancy (mehrere GitLab-Instanzen)

Der Client ist nativ multi-tenant. Die Menge der Instanzen wird einmal in der gemeinsamen agent-utilities-XDG-Konfiguration (~/.config/agent-utilities/config.json) unter gitlab_instances deklariert — dieselbe Liste, die der Knowledge-Graph-GitLab-Indexer liest, sodass eine Konfiguration sowohl die Code-/Metadaten-Indizierung als auch jeden API-/MCP-Aufruf steuert:

{
  "gitlab_instances": [
    {"name": "internal", "url": "https://gitlab.example.invalid", "token": "<GITLAB_TOKEN>", "tls_profile": "private-pki"},
    {"name": "public",   "url": "https://gitlab.com",  "token": "<GITLAB_TOKEN>"}
  ]
}

Zielen Sie von der Client-Factory aus per Name auf einen Mandanten; eine nackte URL funktioniert weiterhin, und eine nicht gesetzte Instanz löst zur ersten konfigurierten auf (sonst GITLAB_URL/GITLAB_TOKEN):

from gitlab_api.auth import get_client
from gitlab_api.instances import list_configured_instances

internal = get_client(instance="internal")   # resolves URL, token, and TLS profile
public   = get_client(instance="public")
default  = get_client()                        # first configured / GITLAB_URL fallback
names    = [i.name for i in list_configured_instances()]

Der MCP-Server stellt ein gitlab_instances-Tool (action=list|get) bereit, um die konfigurierten Mandanten zu ermitteln (Tokens werden nie zurückgegeben). Wenn keine Instanzen konfiguriert sind, greift der Connector auf das bisher verwendete Single-Host-GITLAB_URL/GITLAB_TOKEN zurück.

Sicherheit & Governance

Direkt auf dem unternehmensreifen agent-utilities-Kern aufbauend, werden die Standard-Sicherheitsparameter vollständig unterstützt:

Zugriffskontrolle & Policy-Durchsetzung

Eunomia-Policies: Fein granulare, policygesteuerte Tool-Autorisierung. Unterstützt none, lokale embedded (mcp_policies.json) oder zentralisierte remote-Modi.
OIDC-Token-Delegation: Konform mit RFC 8693-Token-Austausch für die Weitergabe authentifizierter Benutzeranmeldedaten von Web-UI / ACP → Agent → MCP.
Bereichsbezogene Anmeldedaten: Ausführungskontext läuft eingeschränkt auf die spezifische Aufruferidentität.

Laufzeit-Sicherheitsraster

Funktion	Funktionalität	Aktivierung
Tool Guard	Sensitivitätsprüfung mit Human-in-the-Loop-Validierung	Standardmäßig aktiv
Prompt-Injection-Abwehr	Eingabescanning, Wiederholungsüberwachung und rekursive Schleifenblockaden	Standardmäßig aktiv
Context-Safety-Guard	Stuck-Loop-Erkennung und präventive Warnungen bei kontextuellem Überlauf	Standardmäßig aktiv

Installation

Wählen Sie das Extra, das zu dem passt, was Sie ausführen möchten:

Extra	Installiert	Verwenden, wenn
`gitlab-api[mcp]`	Connector-fokussierter MCP-Server (`agent-utilities[mcp]` — FastMCP/FastAPI + `epistemic-graph[full]`)	Sie nur den MCP-Server ausführen (kleinste Installation / Image)
`gitlab-api[agent]`	Agent-Laufzeit (`agent-utilities[agent-runtime,logfire]` — Modell-Orchestrierung + `epistemic-graph[full]`)	Sie den integrierten Agenten ausführen
`gitlab-api[all]`	Alles (`mcp` + `agent` + `gql` + `logfire`)	Entwicklung / beide Oberflächen

# Connector-focused MCP server (includes the shared graph engine)
uv pip install "gitlab-api[mcp]"

# Agent runtime (adds model orchestration to the shared graph engine)
uv pip install "gitlab-api[agent]"

# Everything (development)
uv pip install "gitlab-api[all]"      # or: python -m pip install "gitlab-api[all]"

Container-Images (`:mcp` vs. `:agent`)

Ein mehrstufiges docker/Dockerfile erstellt zwei passend dimensionierte Images, ausgewählt über --target:

Image-Tag	Build-Ziel	Inhalt	Entrypoint
`example/gitlab-api:mcp`	`--target mcp`	`gitlab-api[mcp]` — auf den Connector fokussiert, enthält `epistemic-graph[full]`; kein Modell-Orchestrierungs-Stack	`gitlab-mcp`
`example/gitlab-api@sha256:<digest>`	`--target agent` (Standard)	`gitlab-api[agent]` — Agent-Runtime, Modell-Orchestrierung + `epistemic-graph[full]`	`gitlab-agent`

docker build --target mcp   -t example/gitlab-api:mcp    docker/   # connector-focused MCP server
docker build --target agent -t example/gitlab-api:agent-local docker/   # agent runtime

docker/mcp.compose.yml führt den auf den Connector fokussierten :mcp-Server aus; docker/agent.compose.yml führt den Agenten (unveränderlicher Agenten-Digest) mit einem ko-lokalisierten :mcp-Sidecar aus.

Wissensgraph-Datenbank (`epistemic-graph`)

Sowohl [mcp] als auch [agent] bringen die epistemic-graph-Engine über die erforderliche Kernabhängigkeit Agent Utilities (epistemic-graph[full]) mit. Das Extra [mcp] hält den Server auf den Connector fokussiert; [agent] ermöglicht zusätzlich die Modell-Orchestrierung. Lokale Bereitstellungen können die gebündelte Engine verwenden. Für Produktion oder gemeinsam genutzten Zustand betreiben Sie epistemic-graph als dedizierten Datenbankdienst und konfigurieren Sie die Laufzeit so, dass sie diesen verwendet. Bereitstellungsrezepte (Single-Node + Raft-HA), Verbindungskonfiguration und Architekturdiagramme sind im Bereitstellungsleitfaden für epistemic-graph dokumentiert.

Dokumentation

Die vollständige Dokumentation ist als offizielle Dokumentationsseite veröffentlicht und ist die empfohlene Referenz für Installation, Bereitstellung und den täglichen Betrieb.

Seite	Inhalt
Installation	pip, Quellcode, Extras, vorgefertigtes Docker-Image
Bereitstellung	Betreiben der MCP- und Agent-Server, Compose, Caddy + Technitium, env-Konfiguration
Nutzung	die MCP-Tools, der `Api`-Client, die CLI
Basisplattform	GitLab mit Docker bereitstellen
Übersicht	die aktionsgesteuerte Tool-Oberfläche und Architektur
Konzepte	Konzeptregister (`CONCEPT:GL-*`)

Repository-Eigentümer

GitHub followers GitHub User's stars

Mitwirken

Beiträge sind willkommen! Bitte stellen Sie die Codequalität sicher, indem Sie vor dem Einreichen von Pull Requests lokale Prüfungen ausführen:

Code mit ruff format . formatieren
Code mit ruff check . linten
Typsicherheit mit mypy . validieren
Testsuiten mit pytest ausführen

Bereitstellung mit `agent-utilities-deployment`

Stellen Sie dieses Paket mit dem konsolidierten agent-utilities-deployment-Workflow bereit. Er wählt einen Pfad für ein installiertes Paket, eine editierbare Quelle oder einen unveränderlichen Container; erfasst nur Laufzeit-Secret- und TLS-Profil-Referenzen in AgentConfig; und führt Doctor-, Registrierungs-, Richtlinien-, Observability- und Rollback-Gates aus. Bitten Sie Ihren Agenten, "gitlab-api mit agent-utilities-deployment bereitzustellen".

Installationsmodus	Befehl
Installiertes Paket	`uv tool install "gitlab-api[mcp]"`, dann `gitlab-mcp` ausführen
Editierbare Quelle	`uv pip install -e ".[agent]"`, dann `gitlab-mcp` ausführen
Unveränderlicher Container	`registry.example.invalid/gitlab-api@sha256:<digest>` über den vom Betreiber ausgewählten Orchestrator bereitstellen

Das Repository enthält keine Bereitstellungsprofile, keine Anmeldeinformationswerte, keine Zertifikatspfade und keine umgebungsspezifischen Endpunkte. Stellen Sie diese zur Laufzeit über AgentConfig und den konfigurierten Secret-Provider bereit.

Vertrag für verwaltete Fähigkeiten

Dieses Paket enthält eine kompakte kanonische Skill-Oberfläche mit spezialisierten Prozeduren, die als referenzierte Workflows vorgehalten werden. Die aktuellen MCP-Tools, Skill-Metadaten, connector_manifest.yml, Ontologie, Mappings, Shapes, Fixtures, Migrationen, Tool-Schema-Fingerabdrücke und Zertifizierungsmetadaten bilden einen versionierten Fähigkeitenvertrag. Validieren Sie sie gemeinsam; verlassen Sie sich nicht auf veraltete Tool-Namen oder historische aufgabenspezifische Skill-Wrapper.

Laufzeit-Endpunkte, Anmeldeinformationen, Zertifikatsvertrauen, Mandantenidentität, Aufbewahrung und Observability-Richtlinie sind Bereitstellungsinputs und niemals im Paket enthaltene Werte. Siehe Konfiguration, Vertrauen und Datenschutz, bevor Sie einen Netzwerktransport, Connector-Ingestion, GraphOS-Delegierung oder Trace-Export aktivieren.

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivitySlowing

ResponsivenessUnresponsive

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

GitLab MCP Server A
io.github.jmrplens
Go MCP server for GitLab: 2 dynamic tools reach 1000+ REST/GraphQL actions. Free/CE, no paid tier.
CI/CD & DevOps Developer Tools Version Control
2144
mcpOAuth
com.gitlab
Official GitLab MCP Server
Version Control CI/CD & DevOps Developer Tools
2
neverinfamous-memory-journal-mcp
ai.smithery
A MCP server built for developers enabling Git based project management with project and personal…
Version Control Developer Tools Project Management
320
Gitlab B
io.github.pipeworx-io
GitLab MCP — wraps the GitLab REST API v4 (BYO API key)
Version Control CI/CD & DevOps Developer Tools
2

Related MCP Servers

GitLab MCP Serverofficial
Version Control Project Management Developer Tools
modelcontextprotocol
-
license
A
quality
A
maintenance
MCP Server for the GitLab API, enabling project management, file operations, and more.
Updated 19 hours ago (2026-10-10 17:35 UTC)
9
5,547 npm
91,120
MIT
Kepler MCP GitLab Server
Version Control Developer Tools
ryan-rbw
A
license
Not graded
quality
D
maintenance
Production-ready MCP server providing GitLab integration with OAuth authentication, enabling AI assistants to manage projects, issues, merge requests, branches, files, and commits across GitLab instances.
Updated 10 months ago (2025-12-08 14:10 UTC)
MIT
gitlab-mcp
Version Control CI/CD & DevOps Developer Tools
EllGree
A
license
Not graded
quality
D
maintenance
MCP server for interacting with GitLab API, supporting both self-hosted instances and gitlab.com. Provides tools for managing issues, merge requests, code review, pipelines, milestones, releases, search, and file access.
Updated 5 months ago (2026-05-22 12:23 UTC)
351 npm
MIT
mcp-gitlab
Version Control CI/CD & DevOps Developer Tools
vish288
A
license
Not graded
quality
A
maintenance
MCP server for the GitLab REST API providing tools to manage projects, merge requests, pipelines, CI/CD variables, approvals, issues, and code reviews.
Updated 20 hours ago (2026-10-10 17:21 UTC)
9,306 PyPI
6
MIT