de en es ko zh

gitlab-api

Name: gitlab-api
Author: Knuckles-Team

by Knuckles-Team

Overview Schema Related Servers Score Discussions

Python

Hybrid

Gitlab Api

CLI o API | MCP | Agente

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

Versión: 27.1.0

Documentación — La instalación, el despliegue, el uso a través de las interfaces API, CLI y MCP, el servidor de agente A2A integrado y las guías para aprovisionar la instancia de GitLab subyacente se mantienen en la documentación oficial.

Related MCP server: Kepler MCP GitLab Server

Resumen

Gitlab Api es un servidor de agente y Model Context Protocol (MCP) de nivel de producción diseñado para interactuar directamente con GitLab API + MCP Server + A2A Server.

Características principales

Herramientas MCP consolidadas enrutadas por acción: Minimiza la sobrecarga de tokens y elimina la inflación de herramientas en los contextos de LLM al agrupar métodos en módulos de herramientas optimizados y activables.
Seguridad de nivel empresarial: Soporte integral para políticas de Eunomia, delegación de tokens OIDC y seguimiento granular del contexto de ejecución.
Agente de grafo integrado: Agente Pydantic AI integrado que soporta el Agent Control Protocol (ACP) y las interfaces web estándar (AG-UI).
Telemetría y trazado nativos: Exportaciones OpenTelemetry listas para usar y trazado nativo de Langfuse.

CLI o API

Este agente envuelve la API de GitLab API + MCP Server + A2A Server. Puedes interactuar con él programáticamente o a través de sus puntos de entrada de ejecución integrados.

Las instrucciones detalladas sobre cómo usar los wrappers de API subyacentes, los enlaces de esquema extendidos y las referencias del SDK para desarrolladores se mantienen en docs/index.md.

MCP

Este servidor utiliza herramientas dinámicas enrutadas por acción para optimizar la sobrecarga de tokens y maximizar la compatibilidad con IDE.

Superficie de herramientas — `MCP_TOOL_MODE`

Establece MCP_TOOL_MODE (en el ~/.config/agent-utilities/config.json compartido o en el entorno): condensed (predeterminado — las herramientas enrutadas por acción a continuación), verbose (una herramienta nombrada 1:1 por método de API, p. ej. gitlab_get_branches(...), etiquetada verbose), o both. Filtra el conjunto verbose con --tools tag:verbose / MCP_ENABLED_TAGS=verbose. Consulta la guía de MCP Tool Modes de agent-utilities.

Herramientas MCP disponibles

Generado automáticamente desde el servidor MCP en vivo — no editar a mano.

Herramientas condensadas enrutadas por acción (predeterminado — `MCP_TOOL_MODE=condensed`)

MCP Tool	Toggle Env Var	Description
`api_request`	`CUSTOM_APITOOL`	Ejecuta solicitudes arbitrarias de la API REST de GitLab directamente.
`gitlab_branches`	`BRANCHESTOOL`	Gestiona las operaciones de ramas de GitLab.
`gitlab_commits`	`COMMITSTOOL`	Gestiona las operaciones de commits de GitLab.
`gitlab_deploy_tokens`	`DEPLOY_TOKENSTOOL`	Gestiona las operaciones de tokens de despliegue de GitLab.
`gitlab_discover_graphql_schema`	`GRAPHQLTOOL`	Descubre el esquema GraphQL dinámico de GitLab, incluidos tipos, campos y atributos personalizados en tiempo real.
`gitlab_environments`	`ENVIRONMENTSTOOL`	Gestiona las operaciones de entornos de GitLab.
`gitlab_epics`	`EPICSTOOL`	Gestiona los epics de GitLab.
`gitlab_graphql`	`GRAPHQLTOOL`	Ejecuta consultas y mutaciones GraphQL sin procesar de forma nativa en GitLab.
`gitlab_graphql_ops`	`GRAPHQL_OPSTOOL`	Ejecuta una operación GraphQL tipada de GitLab por nombre.
`gitlab_groups`	`GROUPSTOOL`	Gestiona las operaciones de grupos de GitLab.
`gitlab_ingest_pipelines`	`MISCTOOL`	Ingiere de forma nativa ejecuciones de pipelines de CI de GitLab (+ trabajos) en epistemic-graph.
`gitlab_ingest_projects`	`MISCTOOL`	Ingiere de forma nativa proyectos de GitLab en epistemic-graph como nodos :Project tipados.
`gitlab_instances`	`MISCTOOL`	Lista los tenants de GitLab configurados (CONCEPT:AU-KG.backend.declared-columns-so-schema).
`gitlab_issues`	`ISSUESTOOL`	Gestiona los issues de GitLab.
`gitlab_jobs`	`JOBSTOOL`	Gestiona las operaciones de trabajos de GitLab.
`gitlab_labels`	`LABELSTOOL`	Gestiona las etiquetas de GitLab.
`gitlab_members`	`MEMBERSTOOL`	Gestiona las operaciones de miembros de GitLab.
`gitlab_merge_requests`	`MERGE_REQUESTSTOOL`	Gestiona las operaciones de merge requests de GitLab.
`gitlab_merge_rules`	`MERGE_RULESTOOL`	Gestiona las operaciones de reglas de merge de GitLab.
`gitlab_milestones`	`MILESTONESTOOL`	Gestiona los hitos de GitLab.
`gitlab_namespaces`	`NAMESPACESTOOL`	Gestiona las operaciones de namespaces de GitLab.
`gitlab_notes`	`NOTESTOOL`	Gestiona notas/comentarios de GitLab en issues, merge requests, commits y epics.
`gitlab_packages`	`PACKAGESTOOL`	Gestiona las operaciones de paquetes de GitLab.
`gitlab_pipeline_schedules`	`PIPELINE_SCHEDULESTOOL`	Gestiona las operaciones de programaciones de pipelines de GitLab.
`gitlab_pipelines`	`PIPELINESTOOL`	Gestiona las operaciones de pipelines de GitLab.
`gitlab_projects`	`PROJECTSTOOL`	Gestiona las operaciones de proyectos de GitLab.
`gitlab_protected_branches`	`PROTECTED_BRANCHESTOOL`	Gestiona las operaciones de ramas protegidas de GitLab.
`gitlab_releases`	`RELEASESTOOL`	Gestiona las operaciones de releases de GitLab.
`gitlab_runners`	`RUNNERSTOOL`	Gestiona las operaciones de runners de GitLab.
`gitlab_snippets`	`SNIPPETSTOOL`	Gestiona los snippets de GitLab.
`gitlab_tags`	`TAGSTOOL`	Gestiona las operaciones de etiquetas de GitLab.
`gitlab_users`	`USERSTOOL`	Gestiona las operaciones de usuarios de GitLab.
`gitlab_vulnerabilities`	`VULNERABILITIESTOOL`	Revisa la lista de dependencias y vulnerabilidades de seguridad de un proyecto (el equivalente de GitLab a GitHub Dependabot).
`gitlab_wiki`	`WIKITOOL`	Gestiona las operaciones de wiki de GitLab.

Herramientas detalladas mapeadas 1:1 a la API (`MCP_TOOL_MODE=verbose` o `both`)

Herramienta MCP	Variable de entorno de conmutación	Descripción
`gitlab_accept_merge_request`	`MERGE_REQUESTSTOOL`	Aceptar (fusionar) una solicitud de fusión.
`gitlab_api_request`	`SYSTEMTOOL`	Realizar una solicitud de API personalizada al servidor de GitLab.
`gitlab_approve_merge_request`	`MERGE_REQUESTSTOOL`	Aprobar una solicitud de fusión específica.
`gitlab_archive_project`	`PROJECTSTOOL`	Archivar un proyecto específico.
`gitlab_cancel_merge_when_pipeline_succeeds`	`MERGE_REQUESTSTOOL`	Cancelar la "fusión cuando el pipeline tenga éxito" (fusión automática) en cola de una solicitud de fusión.
`gitlab_cancel_project_job`	`PROJECTSTOOL`	Cancelar un trabajo específico dentro de un proyecto.
`gitlab_cherry_pick_commit`	`REPOSITORIESTOOL`	Hacer cherry-pick de un commit a una nueva rama.
`gitlab_create_branch`	`REPOSITORIESTOOL`	Crear una nueva rama en un proyecto.
`gitlab_create_commit`	`REPOSITORIESTOOL`	Crear un nuevo commit.
`gitlab_create_commit_comment`	`REPOSITORIESTOOL`	Crear un comentario en un commit.
`gitlab_create_environment`	`ENVIRONMENTSTOOL`	Crear un nuevo entorno para un proyecto.
`gitlab_create_epic`	`ISSUESTOOL`	Crear un nuevo epic de grupo.
`gitlab_create_group_deploy_token`	`USERS_GROUPSTOOL`	Crear un token de despliegue para un grupo.
`gitlab_create_issue`	`ISSUESTOOL`	Crear un nuevo issue.
`gitlab_create_label`	`ISSUESTOOL`	Crear una nueva etiqueta.
`gitlab_create_merge_request`	`MERGE_REQUESTSTOOL`	Crear una nueva solicitud de fusión.
`gitlab_create_milestone`	`ISSUESTOOL`	Crear un hito de proyecto.
`gitlab_create_note`	`OTHERTOOL`	Crear una nueva nota/comentario en un issue.
`gitlab_create_pipeline_schedule`	`PIPELINESTOOL`	Crear un horario de pipeline para un proyecto específico.
`gitlab_create_pipeline_schedule_variable`	`PIPELINESTOOL`	Crear una variable para un horario de pipeline.
`gitlab_create_project`	`PROJECTSTOOL`	Crear un nuevo proyecto.
`gitlab_create_project_deploy_token`	`PROJECTSTOOL`	Crear un token de despliegue para un proyecto.
`gitlab_create_project_level_rule`	`PROJECTSTOOL`	Crear una nueva regla de aprobación de solicitudes de fusión a nivel de proyecto.
`gitlab_create_release`	`ENVIRONMENTSTOOL`	Crear una nueva release en un proyecto.
`gitlab_create_release_evidence`	`ENVIRONMENTSTOOL`	Crear evidencia para una release en un proyecto.
`gitlab_create_snippet`	`OTHERTOOL`	Crear un snippet de proyecto o un snippet personal.
`gitlab_create_tag`	`REPOSITORIESTOOL`	Crear una etiqueta en un proyecto.
`gitlab_create_user`	`USERS_GROUPSTOOL`	Crear un nuevo usuario.
`gitlab_create_wiki_page`	`OTHERTOOL`	Crear una nueva página wiki para un proyecto.
`gitlab_delete_branch`	`REPOSITORIESTOOL`	Eliminar una rama en un proyecto.
`gitlab_delete_environment`	`ENVIRONMENTSTOOL`	Eliminar un entorno para un proyecto.
`gitlab_delete_epic`	`ISSUESTOOL`	Eliminar un epic de grupo.
`gitlab_delete_group_deploy_token`	`USERS_GROUPSTOOL`	Eliminar un token de despliegue para un grupo.
`gitlab_delete_issue`	`ISSUESTOOL`	Eliminar un issue.
`gitlab_delete_label`	`ISSUESTOOL`	Eliminar una etiqueta.
`gitlab_delete_merged_branches`	`REPOSITORIESTOOL`	Eliminar todas las ramas fusionadas en un proyecto.
`gitlab_delete_milestone`	`ISSUESTOOL`	Eliminar un hito de proyecto.
`gitlab_delete_note`	`OTHERTOOL`	Eliminar una nota.
`gitlab_delete_pipeline_schedule`	`PIPELINESTOOL`	Eliminar un horario de pipeline para un proyecto específico.
`gitlab_delete_pipeline_schedule_variable`	`PIPELINESTOOL`	Eliminar una variable de un horario de pipeline.
`gitlab_delete_project`	`PROJECTSTOOL`	Eliminar un proyecto específico.
`gitlab_delete_project_deploy_token`	`PROJECTSTOOL`	Eliminar un token de despliegue para un proyecto.
`gitlab_delete_project_level_rule`	`PROJECTSTOOL`	Eliminar una regla de aprobación de solicitudes de fusión a nivel de proyecto.
`gitlab_delete_project_runner`	`PROJECTSTOOL`	Eliminar un runner de un proyecto.
`gitlab_delete_release`	`ENVIRONMENTSTOOL`	Eliminar una release en un proyecto.
`gitlab_delete_runner`	`PIPELINESTOOL`	Eliminar un runner.
`gitlab_delete_shared_project_link`	`PROJECTSTOOL`	Dejar de compartir un proyecto específico con un grupo.
`gitlab_delete_snippet`	`OTHERTOOL`	Eliminar un snippet.
`gitlab_delete_stopped_environments`	`ENVIRONMENTSTOOL`	Eliminar entornos detenidos (aplicaciones de revisión) para un proyecto.
`gitlab_delete_tag`	`REPOSITORIESTOOL`	Eliminar una etiqueta en un proyecto.
`gitlab_delete_user`	`USERS_GROUPSTOOL`	Eliminar un usuario.
`gitlab_delete_wiki_page`	`OTHERTOOL`	Eliminar una página wiki para un proyecto.
`gitlab_download_release_asset`	`ENVIRONMENTSTOOL`	Descargar un activo de release de la release de un grupo.
`gitlab_download_repository_package`	`OTHERTOOL`	Descargar un paquete de repositorio para un proyecto específico.
`gitlab_edit_group`	`USERS_GROUPSTOOL`	Editar un grupo específico.
`gitlab_edit_group_level_rule`	`USERS_GROUPSTOOL`	Editar una configuración de aprobación de solicitudes de fusión a nivel de grupo.
`gitlab_edit_pipeline_schedule`	`PIPELINESTOOL`	Editar un horario de pipeline para un proyecto específico.
`gitlab_edit_project`	`PROJECTSTOOL`	Editar un proyecto específico.
`gitlab_edit_project_level_rule`	`PROJECTSTOOL`	Editar una configuración de aprobación de solicitudes de fusión a nivel de proyecto.
`gitlab_enable_project_runner`	`PROJECTSTOOL`	Habilitar un runner en un proyecto.
`gitlab_erase_project_job`	`PROJECTSTOOL`	Borrar un trabajo específico dentro de un proyecto.
`gitlab_get_approval_state_merge_requests`	`MERGE_REQUESTSTOOL`	Obtener el estado de aprobación de las solicitudes de fusión para un proyecto específico.
`gitlab_get_branch`	`REPOSITORIESTOOL`	Recuperar información sobre una rama específica en un proyecto.
`gitlab_get_branches`	`REPOSITORIESTOOL`	Recuperar información sobre las ramas en un proyecto.
`gitlab_get_commit`	`REPOSITORIESTOOL`	Obtener un commit específico.
`gitlab_get_commit_comments`	`REPOSITORIESTOOL`	Obtener comentarios en un commit.
`gitlab_get_commit_diff`	`REPOSITORIESTOOL`	Obtener el diff de un commit.
`gitlab_get_commit_discussions`	`REPOSITORIESTOOL`	Obtener discusiones en un commit.
`gitlab_get_commit_gpg_signature`	`REPOSITORIESTOOL`	Obtener la firma GPG de un commit.
`gitlab_get_commit_merge_requests`	`REPOSITORIESTOOL`	Obtener solicitudes de fusión asociadas con un commit.
`gitlab_get_commit_references`	`REPOSITORIESTOOL`	Obtener referencias de un commit.
`gitlab_get_commit_statuses`	`REPOSITORIESTOOL`	Obtener estados de un commit.
`gitlab_get_commits`	`REPOSITORIESTOOL`	Obtener commits.
`gitlab_get_deploy_tokens`	`ENVIRONMENTSTOOL`	Obtener todos los tokens de despliegue.
`gitlab_get_environment`	`ENVIRONMENTSTOOL`	Obtener detalles de un entorno específico.
`gitlab_get_environments`	`ENVIRONMENTSTOOL`	Obtener una lista de entornos para un proyecto.
`gitlab_get_epic`	`ISSUESTOOL`	Obtener un epic de grupo específico.
`gitlab_get_epics`	`ISSUESTOOL`	Obtener todos los epics de un grupo.
`gitlab_get_group`	`USERS_GROUPSTOOL`	Obtener detalles de un grupo específico.
`gitlab_get_group_deploy_token`	`USERS_GROUPSTOOL`	Obtener un token de despliegue específico para un grupo.
`gitlab_get_group_deploy_tokens`	`USERS_GROUPSTOOL`	Obtener tokens de despliegue para un grupo específico.
`gitlab_get_group_descendant_groups`	`USERS_GROUPSTOOL`	Obtener grupos descendientes de un grupo específico.
`gitlab_get_group_issues`	`ISSUESTOOL`	Obtener la lista de issues para un grupo (y, por defecto, sus subgrupos).
`gitlab_get_group_level_rule`	`USERS_GROUPSTOOL`	Obtener detalles de una configuración de aprobación de solicitudes de fusión a nivel de grupo.
`gitlab_get_group_members`	`USERS_GROUPSTOOL`	Obtener miembros de un grupo específico.
`gitlab_get_group_merge_requests`	`MERGE_REQUESTSTOOL`	Obtener solicitudes de fusión asociadas con un grupo específico.
`gitlab_get_group_projects`	`PROJECTSTOOL`	Obtener proyectos asociados con un grupo específico.
`gitlab_get_group_releases`	`USERS_GROUPSTOOL`	Obtener información sobre releases en un grupo.
`gitlab_get_group_runners`	`PIPELINESTOOL`	Obtener información sobre runners en un grupo.
`gitlab_get_group_subgroups`	`USERS_GROUPSTOOL`	Obtener subgrupos de un grupo específico.
`gitlab_get_group_vulnerabilities`	`VULNERABILITIESTOOL`	Obtener hallazgos de vulnerabilidades de seguridad de un grupo (Ultimate).
`gitlab_get_groups`	`USERS_GROUPSTOOL`	Obtener una lista de grupos.
`gitlab_get_issue`	`ISSUESTOOL`	Obtener un solo issue.
`gitlab_get_issues`	`ISSUESTOOL`	Obtener lista de issues. Puede filtrar por project_id.
`gitlab_get_label`	`ISSUESTOOL`	Obtener una etiqueta específica por nombre.
`gitlab_get_labels`	`ISSUESTOOL`	Obtener todas las etiquetas de un proyecto.
`gitlab_get_latest_release`	`ENVIRONMENTSTOOL`	Obtener información sobre la última release en un proyecto.
`gitlab_get_latest_release_asset`	`ENVIRONMENTSTOOL`	Obtener el activo de la última release en un proyecto.
`gitlab_get_latest_release_evidence`	`ENVIRONMENTSTOOL`	Obtener evidencia de la última release en un proyecto.
`gitlab_get_merge_request_level_rules`	`MERGE_REQUESTSTOOL`	Obtener reglas de aprobación a nivel de solicitud de fusión para un proyecto y una solicitud de fusión específicos.
`gitlab_get_merge_requests`	`MERGE_REQUESTSTOOL`	Obtener una lista de solicitudes de fusión.
`gitlab_get_milestone`	`ISSUESTOOL`	Obtener un hito de proyecto específico.
`gitlab_get_milestones`	`ISSUESTOOL`	Obtener todos los hitos de un proyecto.
`gitlab_get_namespace`	`USERS_GROUPSTOOL`	Obtener información sobre un namespace específico.
`gitlab_get_namespaces`	`USERS_GROUPSTOOL`	Obtener información sobre namespaces.
`gitlab_get_nested_projects_by_group`	`PROJECTSTOOL`	Obtener información sobre proyectos anidados dentro de un grupo.
`gitlab_get_note`	`OTHERTOOL`	Obtener una nota específica.
`gitlab_get_notes`	`OTHERTOOL`	Obtener todas las notas de un issue específico.
`gitlab_get_pipeline`	`PIPELINESTOOL`	Obtener información sobre un pipeline específico en un proyecto.
`gitlab_get_pipeline_jobs`	`PIPELINESTOOL`	Obtener trabajos asociados con un pipeline específico dentro de un proyecto.
`gitlab_get_pipeline_schedule`	`PIPELINESTOOL`	Obtener información sobre un horario de pipeline específico en un proyecto.
`gitlab_get_pipeline_schedules`	`PIPELINESTOOL`	Obtener horarios de pipeline para un proyecto específico.
`gitlab_get_pipelines`	`PIPELINESTOOL`	Obtener información sobre pipelines para un proyecto específico.
`gitlab_get_pipelines_triggered_from_schedule`	`PIPELINESTOOL`	Obtener pipelines activados desde un horario de pipeline específico.
`gitlab_get_project`	`PROJECTSTOOL`	Obtener información sobre un proyecto específico.
`gitlab_get_project_contributors`	`PROJECTSTOOL`	Obtener información sobre los contribuidores de un proyecto.
`gitlab_get_project_dependencies`	`VULNERABILITIESTOOL`	Obtener la Lista de Dependencias de un proyecto (todas las dependencias detectadas).
`gitlab_get_project_deploy_token`	`PROJECTSTOOL`	Obtener un token de despliegue específico para un proyecto.
`gitlab_get_project_deploy_tokens`	`PROJECTSTOOL`	Obtener tokens de despliegue para un proyecto específico.
`gitlab_get_project_groups`	`PROJECTSTOOL`	Obtener grupos asociados con un proyecto específico.
`gitlab_get_project_job`	`PROJECTSTOOL`	Obtener detalles de un trabajo específico dentro de un proyecto.
`gitlab_get_project_job_log`	`PROJECTSTOOL`	Obtener el registro de un trabajo específico dentro de un proyecto.
`gitlab_get_project_jobs`	`PROJECTSTOOL`	Obtener trabajos asociados con un proyecto específico.
`gitlab_get_project_level_merge_request_rule`	`PROJECTSTOOL`	Obtener detalles de una regla de aprobación de solicitudes de fusión a nivel de proyecto específica.
`gitlab_get_project_level_merge_request_rules`	`PROJECTSTOOL`	Obtener reglas de aprobación de solicitudes de fusión a nivel de proyecto.
`gitlab_get_project_level_rule`	`PROJECTSTOOL`	Obtener detalles de una configuración de aprobación de solicitudes de fusión a nivel de proyecto.
`gitlab_get_project_members`	`PROJECTSTOOL`	Obtener miembros de un proyecto específico.
`gitlab_get_project_merge_request`	`PROJECTSTOOL`	Obtener detalles de una solicitud de fusión específica en un proyecto.
`gitlab_get_project_merge_requests`	`PROJECTSTOOL`	Obtener solicitudes de fusión para un proyecto específico.
`gitlab_get_project_runners`	`PROJECTSTOOL`	Obtener información sobre runners en un proyecto.
`gitlab_get_project_statistics`	`PROJECTSTOOL`	Obtener estadísticas para un proyecto específico.
`gitlab_get_project_vulnerabilities`	`VULNERABILITIESTOOL`	Obtener vulnerabilidades de seguridad de un proyecto (Ultimate).
`gitlab_get_projects`	`PROJECTSTOOL`	Obtener información sobre proyectos.
`gitlab_get_protected_branch`	`REPOSITORIESTOOL`	Obtener información sobre una rama protegida específica en un proyecto.
`gitlab_get_protected_branches`	`REPOSITORIESTOOL`	Obtener información sobre ramas protegidas en un proyecto.
`gitlab_get_protected_environment`	`ENVIRONMENTSTOOL`	Obtener detalles de un entorno protegido específico.
`gitlab_get_protected_environments`	`ENVIRONMENTSTOOL`	Obtener una lista de entornos protegidos para un proyecto.
`gitlab_get_protected_tag`	`REPOSITORIESTOOL`	Obtener información sobre una etiqueta protegida específica en un proyecto.
`gitlab_get_protected_tags`	`REPOSITORIESTOOL`	Obtener información sobre etiquetas protegidas en un proyecto.
`gitlab_get_release_by_tag`	`REPOSITORIESTOOL`	Obtener información sobre una release por su etiqueta en un proyecto.
`gitlab_get_releases`	`ENVIRONMENTSTOOL`	Obtener información sobre releases en un proyecto.
`gitlab_get_repository_packages`	`OTHERTOOL`	Obtener información sobre paquetes de repositorio para un proyecto específico.
`gitlab_get_runner`	`PIPELINESTOOL`	Obtener información sobre un runner específico.
`gitlab_get_runner_jobs`	`PIPELINESTOOL`	Obtener trabajos para un runner específico.
`gitlab_get_runners`	`PIPELINESTOOL`	Obtener información sobre runners.
`gitlab_get_snippet`	`OTHERTOOL`	Obtener un snippet específico.
`gitlab_get_snippets`	`OTHERTOOL`	Obtener lista de snippets. Puede filtrar por project_id.
`gitlab_get_tag`	`REPOSITORIESTOOL`	Obtener información sobre una etiqueta específica en un proyecto.
`gitlab_get_tags`	`REPOSITORIESTOOL`	Obtener información sobre etiquetas en un proyecto.
`gitlab_get_user`	`USERS_GROUPSTOOL`	Obtener información sobre un usuario específico.
`gitlab_get_users`	`USERS_GROUPSTOOL`	Obtener información sobre usuarios.
`gitlab_get_vulnerability`	`VULNERABILITIESTOOL`	Obtener una sola vulnerabilidad por su ID global (Ultimate).
`gitlab_get_wiki_list`	`OTHERTOOL`	Obtener una lista de páginas wiki para un proyecto.
`gitlab_get_wiki_page`	`OTHERTOOL`	Obtener información sobre una página wiki específica.
`gitlab_merge_request_level_approvals`	`MERGE_REQUESTSTOOL`	Obtener aprobaciones para una solicitud de fusión específica.
`gitlab_pause_runner`	`PIPELINESTOOL`	Pausar o reanudar un runner específico.
`gitlab_post_build_status_to_commit`	`REPOSITORIESTOOL`	Publicar el estado de compilación en un commit.
`gitlab_protect_branch`	`REPOSITORIESTOOL`	Proteger una rama específica en un proyecto.
`gitlab_protect_environment`	`ENVIRONMENTSTOOL`	Proteger un entorno para un proyecto.
`gitlab_protect_tag`	`REPOSITORIESTOOL`	Proteger una etiqueta en un proyecto.
`gitlab_publish_repository_package`	`OTHERTOOL`	Publicar un paquete de repositorio para un proyecto específico.
`gitlab_register_new_runner`	`PIPELINESTOOL`	Registrar un nuevo runner.
`gitlab_require_code_owner_approvals_single_branch`	`REPOSITORIESTOOL`	Requerir aprobaciones de propietarios de código para una rama específica en un proyecto.
`gitlab_reset_gitlab_runner_token`	`PIPELINESTOOL`	Restablecer el token de registro del runner de GitLab.
`gitlab_reset_group_runner_token`	`PIPELINESTOOL`	Restablecer el token de registro para el runner de un grupo.
`gitlab_reset_project_runner_token`	`PROJECTSTOOL`	Restablecer el token de registro para el runner de un proyecto.
`gitlab_reset_token`	`OTHERTOOL`	Restablecer el token de autenticación para un runner.
`gitlab_retry_project_job`	`PROJECTSTOOL`	Reintentar un trabajo específico dentro de un proyecto.
`gitlab_revert_commit`	`REPOSITORIESTOOL`	Revertir un commit.
`gitlab_run_pipeline`	`PIPELINESTOOL`	Ejecutar un pipeline para un proyecto específico.
`gitlab_run_pipeline_schedule`	`PIPELINESTOOL`	Ejecutar un horario de pipeline para un proyecto específico.
`gitlab_run_project_job`	`PROJECTSTOOL`	Ejecutar un trabajo específico dentro de un proyecto.
`gitlab_share_project`	`PROJECTSTOOL`	Compartir un proyecto específico con un grupo.
`gitlab_stop_environment`	`ENVIRONMENTSTOOL`	Detener un entorno para un proyecto.
`gitlab_stop_stale_environments`	`ENVIRONMENTSTOOL`	Detener entornos obsoletos para un proyecto.
`gitlab_take_pipeline_schedule_ownership`	`PIPELINESTOOL`	Tomar posesión de un horario de pipeline para un proyecto específico.
`gitlab_unapprove_merge_request`	`MERGE_REQUESTSTOOL`	Desaprobar una solicitud de fusión específica.
`gitlab_unarchive_project`	`PROJECTSTOOL`	Desarchivar un proyecto específico.
`gitlab_unprotect_branch`	`REPOSITORIESTOOL`	Desproteger una rama específica en un proyecto.
`gitlab_unprotect_environment`	`ENVIRONMENTSTOOL`	Desproteger un entorno para un proyecto.
`gitlab_unprotect_tag`	`REPOSITORIESTOOL`	Desproteger una etiqueta en un proyecto.
`gitlab_update_environment`	`ENVIRONMENTSTOOL`	Actualizar un entorno existente para un proyecto.
`gitlab_update_epic`	`ISSUESTOOL`	Actualizar un epic de grupo.
`gitlab_update_issue`	`ISSUESTOOL`	Actualizar un issue.
`gitlab_update_label`	`ISSUESTOOL`	Actualizar una etiqueta existente.
`gitlab_update_milestone`	`ISSUESTOOL`	Actualizar un hito de proyecto.
`gitlab_update_note`	`OTHERTOOL`	Actualizar una nota.
`gitlab_update_project_level_rule`	`PROJECTSTOOL`	Actualizar una regla de aprobación de solicitudes de fusión a nivel de proyecto existente.
`gitlab_update_protected_environment`	`ENVIRONMENTSTOOL`	Actualizar un entorno protegido para un proyecto.
`gitlab_update_release`	`ENVIRONMENTSTOOL`	Actualizar información sobre una release en un proyecto.
`gitlab_update_runner_details`	`PIPELINESTOOL`	Actualizar detalles para un runner específico.
`gitlab_update_snippet`	`OTHERTOOL`	Actualizar un snippet.
`gitlab_update_user`	`USERS_GROUPSTOOL`	Actualizar un usuario existente.
`gitlab_update_wiki_page`	`OTHERTOOL`	Actualizar una página wiki existente para un proyecto.
`gitlab_upload_wiki_page_attachment`	`OTHERTOOL`	Subir un adjunto a una página wiki para un proyecto.
`gitlab_verify_runner_authentication`	`PIPELINESTOOL`	Verificar la autenticación del runner.

34 herramienta(s) enrutada(s) por acción (predeterminado) · 196 herramienta(s) verbose 1:1. Cada una está habilitada salvo que su conmutador <DOMAIN>TOOL esté en false; MCP_TOOL_MODE selecciona la superficie (condensed predeterminado · verbose 1:1 · both). Generado automáticamente: no editar.

Los esquemas detallados de las herramientas, las formas de los parámetros y las restricciones de validación se conservan en docs/usage.md.

Selección y visibilidad dinámicas de herramientas

Este servidor MCP admite la selección dinámica del conjunto de herramientas y el filtrado de visibilidad en tiempo de ejecución. Esto le permite restringir el conjunto de herramientas expuestas para evitar saturar la ventana de contexto del LLM.

Puede configurar el filtrado de herramientas a través de varios canales de entrada:

Argumentos de CLI: pase --tools o --toolsets (o sus contrapartes deshabilitadas --disabled-tools y --disabled-toolsets) durante el inicio.
Variables de entorno: defina las variables de entorno estándar:
- MCP_ENABLED_TOOLS / MCP_DISABLED_TOOLS
- MCP_ENABLED_TAGS / MCP_DISABLED_TAGS
Cabeceras de solicitud HTTP SSE: pase cabeceras personalizadas durante la inicialización del transporte:
- x-mcp-enabled-tools / x-mcp-disabled-tools
- x-mcp-enabled-tags / x-mcp-disabled-tags
Parámetros de consulta de solicitud HTTP SSE: añada parámetros de consulta directamente a la URL de conexión del transporte:
- ?tools=tool1,tool2
- ?tags=tag1

Cuando se suministran cadenas de consulta o parámetros, una capa de resolución de Knowledge Graph (sin LLM, que usa DynamicToolOrchestrator) relaciona las intenciones de consulta con etiquetas, nombres o descripciones de herramientas conocidas, con un fallback seguro y una actualización automática de caché en segundo plano cada 24 horas.

Ejemplos de configuración de MCP

Instale el extra [mcp] orientado a conectores. Los ejemplos usan gitlab-api[mcp] para añadir FastMCP / FastAPI a través de agent-utilities[mcp]; el núcleo requerido de Agent Utilities sigue incluyendo epistemic-graph[full]. El extra [agent-runtime] además habilita la orquestación de modelos.

Transporte stdio (IDE locales — 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"
      }
    }
  }
}

Las referencias de tiempo de ejecución requieren un lanzador compatible con alias como GraphOS. Otros lanzadores deben omitir esas referencias e inyectar los valores resueltos a través de su propio límite de secretos de tiempo de ejecución.

Transporte Streamable-HTTP (en red / producción)

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

Alternativamente, conéctese a una instancia Streamable-HTTP previamente desplegada mediante url:

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

Ejecute una imagen de contenedor revisada como un hijo stdio de mínimo privilegio (sin listener ni puerto publicado):

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

Para HTTP de red contenedorizada, proporcione un ingress TLS autenticado (o TLS directo del servidor), los MCP_ALLOWED_HOSTS exactos y una política CIDR exacta de proxy de confianza a través del perfil de despliegue propiedad del operador. El generador no emite ningún listener no autenticado no loopback.

Autogenerado a partir de la superficie de variables de entorno leída del código (MCP_TOOL_MODE + variables del paquete) — no editar.

Opciones de despliegue adicionales

gitlab-api puede ejecutarse como un proceso stdio local o un contenedor, o detrás de un límite de red remoto. La Guía de despliegue contiene el contrato de transporte detallado.

Contenedor local — ejecuta una imagen inmutable revisada como un hijo stdio de mínimo privilegio, sin listener ni puerto publiated.
URL remora — conéctese mediante un ingress HTTPS autenticado proporcionado por el operador. Mantenga su URL, las referencias de identidad salientes, el perfil de confianza y los MCP_ALLOWED_HOSTS exactos en AgentConfig.

Variables de entorno

Variables de entorno del paquete

Variable	Ejemplo	Descripción
`HOST`	`0.0.0.0`
`PORT`	`8000`
`TRANSPORT`	`stdio`	opciones: 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`	opciones: 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`	—	perfil TLS de AgentConfig denominado; en blanco se usa el predeterminado configurado
`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`

Variables heredadas de agent-utilities (se aplican a todos los conectores)

Variable	Ejemplo	Descripción
`MCP_TOOL_MODE`	`intent`	Superficie de herramientas: `intent` \| `condensed` \| `verbose` \| `both`
`MCP_ENABLED_TOOLS`	—	Lista de permitidos de herramientas separada por comas
`MCP_DISABLED_TOOLS`	—	Lista de denegados de herramientas separada por comas
`MCP_ENABLED_TAGS`	—	Lista de permitidos de etiquetas separada por comas
`MCP_DISABLED_TAGS`	—	Lista de denegados de etiquetas separada por comas
`MCP_CLIENT_AUTH`	—	Autenticación saliente del MCP hijo: `oidc-client-credentials` \| `basic` \| `none`
`OIDC_CLIENT_ID`	—	ID de cliente OIDC (autenticación de cuenta de servicio)
`OIDC_CLIENT_SECRET_REF`	`secret://identity/oidc-client-secret`	Referencia de secreto en tiempo de ejecución para la cuenta de servicio OIDC
`MCP_BASIC_AUTH_USERNAME`	—	Nombre de usuario HTTP Basic (`MCP_CLIENT_AUTH=basic`)
`MCP_BASIC_AUTH_PASSWORD_REF`	`secret://identity/mcp-basic-password`	Referencia de secreto en tiempo de ejecución para la autenticación HTTP Basic (`MCP_CLIENT_AUTH=basic`)
`DEBUG`	`False`	Registro detallado (verbose)
`PYTHONUNBUFFERED`	`1`	Salida estándar sin buffer (recomendado en contenedores)
`MCP_URL`	`http://localhost:8000/mcp`	URL del servidor MCP al que se conecta el agente
`PROVIDER`	`openai`	Proveedor de LLM para el agente
`MODEL_ID`	`gpt-4o`	ID de modelo para el agente
`ENABLE_WEB_UI`	`True`	Servir la interfaz web AG-UI

45 variables de paquete + 16 variables heredadas. Generado automáticamente desde .env.example + el conjunto compartido de agent-utilities — no editar.

Cada variable que lee el servidor.

Conexión y credenciales

El conector es de un solo host por defecto y multi-tenant cuando se configura gitlab_instances (consulte Multi-Tenancy). Cuando no hay instancias configuradas, recurre a los valores GITLAB_* de un solo host que se indican a continuación.

Variable	Descripción	Predeterminado
`GITLAB_URL`	URL base de la instancia de GitLab	`https://gitlab.example.com`
`GITLAB_TOKEN`	Token de acceso personal/de proyecto de GitLab (`glpat-…`)	—
`GITLAB_TLS_PROFILE`	Selector opcional de perfil TLS en tiempo de ejecución	(sin establecer)

Las instancias múltiples se declaran una sola vez en gitlab_instances dentro de la configuración XDG compartida de agent-utilities (~/.config/agent-utilities/config.json) — cada entrada tiene name, url, token y un tls_profile opcional. Seleccione un tenant por nombre desde la fábrica de clientes; una instancia sin definir se resuelve a la primera configurada (o bien GITLAB_URL / GITLAB_TOKEN).

Servidor MCP / transporte

Variable	Descripción	Predeterminado
`TRANSPORT`	`stdio`, `streamable-http` o `sse`	`stdio`
`HOST`	Host de enlace (transportes HTTP)	`0.0.0.0`
`PORT`	Puerto de enlace (transportes HTTP)	`8000`
`MCP_TOOL_MODE`	Superficie de herramientas: `condensed`, `verbose` o `both`	`condensed`
`MCP_ENABLED_TOOLS` / `MCP_DISABLED_TOOLS`	Lista de permitidos/denegados de herramientas separada por comas	—
`MCP_ENABLED_TAGS` / `MCP_DISABLED_TAGS`	Lista de permitidos/denegados de etiquetas separada por comas	—
`DEBUG`	Registro detallado (verbose)	`False`
`PYTHONUNBUFFERED`	Salida estándar sin buffer (recomendado en contenedores)	`1`

Alternancias de herramientas

Cada herramienta enrutada por acción se puede deshabilitar individualmente mediante su variable de entorno de conmutación (establecida en false). La lista completa está en la tabla Herramientas MCP disponibles anterior (p. ej. PROJECTSTOOL, MERGE_REQUESTSTOOL, PIPELINESTOOL, GRAPHQLTOOL, CUSTOM_APITOOL).

Telemetría y gobernanza

Variable	Descripción	Predeterminado
`ENABLE_OTEL`	Habilitar la exportación de OpenTelemetry	`True`
`OTEL_EXPORTER_OTLP_ENDPOINT`	Endpoint del recopilador OTLP	—
`OTEL_EXPORTER_OTLP_PUBLIC_KEY` / `OTEL_EXPORTER_OTLP_SECRET_KEY`	Claves de autenticación OTLP	—
`OTEL_EXPORTER_OTLP_PROTOCOL`	Protocolo OTLP (p. ej. `http/protobuf`)	—
`EUNOMIA_TYPE`	Modo de autorización: `none`, `embedded`, `remote`	`none`
`EUNOMIA_POLICY_FILE`	Archivo de política integrado	`mcp_policies.json`
`EUNOMIA_REMOTE_URL`	URL del servidor remoto de Eunomia	—

CLI del agente (solo runtime `[agent]` completo)

Variable	Descripción	Predeterminado
`MCP_URL`	URL del servidor MCP al que se conecta el agente	`http://localhost:8000/mcp`
`PROVIDER`	Proveedor de LLM (p. ej. `openai`)	`openai`
`MODEL_ID`	ID de modelo (p. ej. `gpt-4o`)	`gpt-4o`
`ENABLE_WEB_UI`	Servir la interfaz web AG-UI	`True`

Consulte .env.example como punto de partida de copiar y pegar.

Agente

Este repositorio incluye un Pydantic AI Graph Agent totalmente integrado. Se comunica a través del Agent Control Protocol (ACP) e interactúa sin problemas con la Agent Web UI (AG-UI) y la interfaz de Terminal.

Ejecutar la CLI del agente

Para iniciar el agente interactivo de línea de comandos:

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

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

Orquestación con Docker Compose

El siguiente docker/agent.compose.yml configura conjuntamente el Agente, la Web UI y la interfaz de Terminal:

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"

Las explicaciones detalladas de la arquitectura de nodos del grafo, las configuraciones de habilidades personalizadas y las guías de trazas del agente están disponibles en docs/deployment.md.

Multi-Tenancy (múltiples instancias de GitLab)

El cliente es nativamente multi-tenant. El conjunto de instancias se declara una sola vez en la configuración XDG compartida de agent-utilities (~/.config/agent-utilities/config.json) bajo gitlab_instances — la misma lista que lee el indexador Knowledge-Graph de GitLab, de modo que una única configuración impulsa tanto la indexación de código/metadatos como cada llamada API/MCP:

{
  "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>"}
  ]
}

Seleccione un tenant por nombre desde la fábrica de clientes; una URL simple también funciona, y una instancia sin definir se resuelve a la primera configurada (o bien 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()]

El servidor MCP expone una herramienta gitlab_instances (action=list|get) para descubrir los tenants configurados (los tokens nunca se devuelven). Cuando no hay instancias configuradas, el conector recurre al GITLAB_URL/GITLAB_TOKEN de un solo host que siempre ha utilizado.

Seguridad y gobernanza

Construido directamente sobre el núcleo de agent-utilities, listo para empresas, los parámetros de seguridad estándar cuentan con soporte completo:

Control de acceso y aplicación de políticas

Políticas de Eunomia: Autorización de herramientas detallada y basada en políticas. Admite modos none, embedded local (mcp_policies.json) o remote centralizado.
Delegación de tokens OIDC: Cumple con el intercambio de tokens RFC 8693 para transmitir las credenciales de autenticación del usuario desde Web UI / ACP → Agent → MCP.
Credenciales con ámbito: El contexto de ejecución queda restringido a la identidad específica del llamante.

Matriz de seguridad en tiempo de ejecución

Característica	Funcionalidad	Habilitación
Guardia de herramientas	Inspección de sensibilidad con validación de intervención humana	Habilitada por defecto
Defensa contra inyección de prompts	Escaneo de entradas, monitoreo de repeticiones y bloqueos de bucles recursivos	Habilitada por defecto
Guardia de seguridad de contexto	Detectores de bucles bloqueados y alertas preventivas de desbordamiento contextual	Habilitada por defecto

Instalación

Elija el extra que coincida con lo que desea ejecutar:

Extra	Instala	Úselo cuando
`gitlab-api[mcp]`	Servidor MCP centrado en el conector (`agent-utilities[mcp]` — FastMCP/FastAPI + `epistemic-graph[full]`)	Solo ejecuta el servidor MCP (instalación / imagen más pequeña)
`gitlab-api[agent]`	Runtime del agente (`agent-utilities[agent-runtime,logfire]` — orquestación de modelos + `epistemic-graph[full]`)	Ejecuta el agente integrado
`gitlab-api[all]`	Todo (`mcp` + `agent` + `gql` + `logfire`)	Desarrollo / ambas superficies

# 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]"

Imágenes de contenedor (`:mcp` vs `:agent`)

Un docker/Dockerfile de varias etapas construye dos imágenes de tamaño adecuado, seleccionadas mediante --target:

Etiqueta de imagen	Destino de compilación	Contenido	Punto de entrada
`example/gitlab-api:mcp`	`--target mcp`	`gitlab-api[mcp]` — centrado en el conector, incluye `epistemic-graph[full]`; sin pila de orquestación de modelos	`gitlab-mcp`
`example/gitlab-api@sha256:<digest>`	`--target agent` (predeterminado)	`gitlab-api[agent]` — runtime de agente, orquestación de modelos + `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 ejecuta el servidor :mcp centrado en el conector; docker/agent.compose.yml ejecuta el agente (digest de agente inmutable) con un sidecar :mcp co-ubicado.

Base de datos de grafo de conocimiento (`epistemic-graph`)

Tanto [mcp] como [agent] incluyen el motor epistemic-graph a través de la dependencia principal requerida de Agent Utilities (epistemic-graph[full]). El extra [mcp] mantiene el servidor centrado en el conector; [agent] habilita además la orquestación de modelos. Los despliegues locales pueden usar el motor incluido. Para producción o estado compartido, ejecuta epistemic-graph como un servicio de base de datos dedicado y configura el runtime para usarlo. Las recetas de despliegue (un solo nodo + Raft HA), la configuración de conexión y los diagramas de arquitectura están documentados en la guía de despliegue de epistemic-graph.

Documentación

La documentación completa se publica como el sitio oficial de documentación y es la referencia recomendada para la instalación, el despliegue y la operación diaria.

Página	Contenido
Instalación	pip, código fuente, extras, imagen Docker preconstruida
Despliegue	ejecutar los servidores MCP y de agente, Compose, Caddy + Technitium, configuración de env
Uso	las herramientas MCP, el cliente `Api`, la CLI
Plataforma subyacente	desplegar GitLab con Docker
Visión general	la superficie de herramientas enrutadas por acción y la arquitectura
Conceptos	registro de conceptos (`CONCEPT:GL-*`)

Propietarios del repositorio

GitHub followers GitHub User's stars

Contribuir

¡Las contribuciones son bienvenidas! Por favor, asegura la calidad del código ejecutando las comprobaciones locales antes de enviar pull requests:

Formatea el código con ruff format .
Ejecuta el lint del código con ruff check .
Valida la seguridad de tipos con mypy .
Ejecuta las suites de pruebas con pytest

Despliegue con `agent-utilities-deployment`

Aprovisiona este paquete con el flujo de trabajo consolidado agent-utilities-deployment. Selecciona una ruta de paquete instalado, fuente editable o contenedor inmutable; registra solo referencias de secretos de runtime y de perfiles TLS en AgentConfig; y ejecuta las compuertas de doctor, registro, políticas, observabilidad y rollback. Pide a tu agente que "despliegue gitlab-api con agent-utilities-deployment".

Modo de instalación	Comando
Paquete instalado	`uv tool install "gitlab-api[mcp]"` y luego ejecuta `gitlab-mcp`
Fuente editable	`uv pip install -e ".[agent]"` y luego ejecuta `gitlab-mcp`
Contenedor inmutable	despliega `registry.example.invalid/gitlab-api@sha256:<digest>` mediante el orquestador seleccionado por el operador

El repositorio no incorpora ningún perfil de despliegue, valor de credencial, ruta de certificado ni endpoint específico del entorno. Proporciónalos en tiempo de ejecución a través de AgentConfig y del proveedor de secretos configurado.

Contrato de capacidad gobernada

Este paquete incluye una superficie de habilidades canónica y compacta con procedimientos especializados mantenidos como flujos de trabajo referenciados. Las herramientas MCP actuales, los metadatos de habilidades, connector_manifest.yml, la ontología, los mapeos, las formas, los fixtures, las migraciones, las huellas de esquemas de herramientas y los metadatos de certificación forman un único contrato de capacidad versionado. Valídalos conjuntamente; no confíes en nombres de herramientas obsoletos ni en envoltorios históricos de habilidades por tarea.

Los endpoints de runtime, las credenciales, la confianza de certificados, la identidad del inquilino, la retención y la política de observabilidad son entradas de despliegue y nunca valores empaquetados. Consulta Configuración, confianza y privacidad antes de habilitar un transporte de red, la ingesta del conector, la delegación de GraphOS o la exportación de trazas.

This server cannot be installed

license - permissive license

Not graded

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

2dRelease cycle

147Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

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 4 days ago (2026-08-20 01:12 UTC)
9
5,525
89,748
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 9 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 3 months ago (2026-05-22 12:23 UTC)
514
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 a month ago (2026-07-16 20:17 UTC)
5
MIT

View all related MCP servers

Related MCP Connectors

GitLab MCP Server
Go MCP server for GitLab: 2 dynamic tools reach 1000+ REST/GraphQL actions. Free/CE, no paid tier.
neverinfamous-memory-journal-mcp
A MCP server built for developers enabling Git based project management with project and personal…
Appcircle MCP
MCP server for Appcircle mobile CI/CD platform.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Knuckles-Team/gitlab-api'

If you have feedback or need assistance with the MCP directory API, please join our Discord server