Agentes de IA: Integración de Claude con Jira, Confluence y Sentry
En el panorama actual de laingeniería de software, el cuello de botella no suele ser la generación de código; es el cambio de contexto. Un desarrollador que depura una incidencia en producción debe recopilar datos de diversas plataformas de observabilidad, repositorios de documentación y herramientas de gestión de proyectos. Para reducir esta carga cognitiva, podemos diseñaragentes de IA para procesos de negocio que actúen como capas de orquestación inteligentes.
Este artículo detalla la implementación arquitectónica de un asistente técnico impulsado por Anthropic's Claude 3.5 Sonnet. Crearemos una interfaz unificada que correlacione los datos de error de Sentry, obtenga el contexto arquitectónico de Confluence, y cree incidencias rastreadas en Jira.
Visión general arquitectónica
Utilizaremos una arquitectura RAG (Generación con Recuperación) basada en agentes. A diferencia de los chatbots simples, este sistema utiliza la llamada de funciones (uso de herramientas). Claude no solo generará texto, sino que determinará qué acciones específicas de la API ejecutar en función de las entradas en lenguaje natural.Llamada a funciones (Uso de herramientas). Claude no solo generará texto, sino que determinará qué acciones específicas de la API deben ejecutarse en función de las entradas en lenguaje natural.
Servicios de Ingeniería de LLM y IA
Ofrecemos una completa gama de soluciones impulsadas por IA, que incluyen IA generativa, visión artificial, aprendizaje automático, procesamiento del lenguaje natural y automatización con IA.
La pila incluye:
- Orquestación: Python 3.10+
- LLM: Claude 3.5 Sonnet (a través de la API de Anthropic)
- Marco de integración: LangChain(para la abstracción de herramientas)
- APIs: Jira REST API v3, API de Confluence Cloud, API de Sentry Web
1. La Capa de Observabilidad: Integración con Sentry
El primer paso es permitir que el agente "vea" los problemas de producción. Necesitamos obtener problemas específicos, analizar las trazas de pila y resumir la frecuencia.
Definimos una herramienta que consulta la API de Sentry. Tenga en cuenta el uso de las indicaciones de tipo y los comentarios; Claude utiliza estas definiciones de firma para entender cuándo y cómo llamar a la función.
import requests
from typing import Optional, Dict, Any
from langchain_core.tools import tool
SENTRY_API_BASE = "https://sentry.io/api/0"
SENTRY_AUTH_TOKEN = "your_sentry_auth_token"
@tool
def fetch_sentry_issue(issue_id: str) -> Dict[str, Any]:
"""
Retrieves detailed information about a specific Sentry issue,
including the stack trace and tag summary.
"""
headers = {"Authorization": f"Bearer {SENTRY_AUTH_TOKEN}"}
url = f"{SENTRY_API_BASE}/issues/{issue_id}/"
response = requests.get(url, headers=headers)
response.raise_for_status()
data = response.json()
# Minimize token usage by extracting only relevant context
return {
"title": data.get("title"),
"culprit": data.get("culprit"),
"metadata": data.get("metadata"),
"project": data.get("project", {}).get("slug"),
"permalink": data.get("permalink"),
"lastSeen": data.get("lastSeen")
}
2. La Capa de Contexto: Recuperar documentación de Confluence
Cuando se identifica un error, la solución a menudo se documenta en los manuales de operaciones. Implementamos un sistema de búsqueda que consulta Confluence utilizando CQL (Conferencia Query Language).
from atlassian import Confluence
# Initialize the Atlassian SDK wrapper
confluence = Confluence(
url='https://your-domain.atlassian.net',
username='user@example.com',
password='your_api_token',
cloud=True
)
@tool
def search_runbooks(query: str) -> str:
"""
Searches Confluence for engineering runbooks or technical documentation
related to the error query.
"""
cql = f'siteSearch ~ "{query}" AND label = "runbook"'
results = confluence.cql(cql, limit=3)
context_docs = []
for content in results.get("results", []):
# Fetch full page content
page_id = content["content"]["id"]
page_body = confluence.get_page_by_id(page_id, expand='body.storage')
# Simple HTML stripping (in production, use BeautifulSoup)
text_content = page_body['body']['storage']['value']
context_docs.append(f"Source: {content['content']['title']}\nContent: {text_content[:2000]}...")
return "\n\n".join(context_docs)
3. La Capa de Acción: Creación de Tickets en Jira
El último elemento de nuestros agentes de IA para flujos de trabajo empresariales es la capacidad de tomar medidas. Si Claude analiza un error de Sentry y no encuentra una solución en Confluence, debería proponer la creación de un ticket en Jira.
@tool
def create_jira_ticket(summary: str, description: str, project_key: str = "ENG") -> str:
"""
Creates a new Jira ticket for a confirmed bug or task.
Args:
summary: The title of the ticket.
description: Detailed description including stack trace or analysis.
project_key: The Jira project key (default: ENG).
"""
url = "https://your-domain.atlassian.net/rest/api/3/issue"
headers = {
"Accept": "application/json",
"Content-Type": "application/json"
}
payload = {
"fields": {
"project": {"key": project_key},
"summary": summary,
"description": {
"type": "doc",
"version": 1,
"content": [
{
"type": "paragraph",
"content": [{"type": "text", "text": description}]
}
]
},
"issuetype": {"name": "Bug"}
}
}
# Auth handled via requests Session or similar in prod
response = requests.post(
url,
json=payload,
auth=("user@example.com", "your_api_token"),
headers=headers
)
if response.status_code == 201:
return f"Ticket created successfully: {response.json()['key']}"
else:
return f"Failed to create ticket: {response.text}"
Servicios de Ingeniería de LLM y IA
Ofrecemos una completa gama de soluciones impulsadas por IA, que incluyen IA generativa, visión artificial, aprendizaje automático, procesamiento del lenguaje natural y automatización con IA.
4. Orquestación con Claude
Vinculamos estas herramientas al modelo. Claude 3.5 Sonnet destaca en la navegación de este grafo: primero, recuperando el error de Sentry, luego, leyendo la documentación de Confluence y, finalmente, generando el ticket de Jira si la documentación no resuelve el problema.
from langchain_anthropic import ChatAnthropic
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
# Initialize Model
llm = ChatAnthropic(
model="claude-3-5-sonnet-20240620",
temperature=0,
api_key="your_anthropic_key"
)
# Bind tools
tools = [fetch_sentry_issue, search_runbooks, create_jira_ticket]
# Define the System Prompt
prompt = ChatPromptTemplate.from_messages([
("system", "You are a Site Reliability Engineering assistant. "
"You have access to Sentry for errors, Confluence for docs, and Jira for tracking. "
"When analyzing an error, always check Confluence for runbooks first. "
"If no solution is found, create a Jira ticket with all technical details."),
("human", "{input}"),
("placeholder", "{agent_scratchpad}"),
])
# Create the Agent
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Execution Example
query = "Analyze Sentry issue ID 12345. If there is no runbook for this Exception, create a ticket."
response = agent_executor.invoke({"input": query})
print(response['output'])
Desafíos y seguridad en la implementación
Al implementar estas integraciones en un entorno empresarial, considere lo siguiente:
- Acceso con el mínimo privilegio: No utilice tokens de API de administrador. Cree cuentas de servicio en Jira y Sentry con permisos limitados (por ejemplo,
browse_projects,create_issues,event:read). - Gestión de la Ventana de Contexto: Los registros de Sentry pueden ser muy extensos. Trunce las trazas de pila o resúpalas antes de pasarlas al LLM para evitar alcanzar los límites de tokens o aumentar la latencia.
- Con Persona en el Bucle: Para las operaciones de escritura (como
create_jira_ticket), es mejor práctica devolver la acción propuesta al usuario para su confirmación antes de la ejecución, en lugar de ejecutarlas automáticamente.
Conclusión
Al integrar estrechamente los LLMs con su sistema de registro, transforma la documentación y el registro pasivos en un soporte de ingeniería activo. Esto reduce el Tiempo Medio de Resolución (MTTR) y preserva el estado de flujo del desarrollador.
Para organizaciones que buscan ampliar esta arquitectura,4Geeks ofrece servicios especializados de ingeniería de IA para crear agentes personalizados y seguros de alto rendimiento que se adapten a su infraestructura empresarial específica.para desarrollar agentes personalizados, seguros y de alto rendimiento, adaptados a la infraestructura específica de su empresa.
Servicios de Ingeniería de LLM y IA
Ofrecemos una completa gama de soluciones impulsadas por IA, que incluyen IA generativa, visión artificial, aprendizaje automático, procesamiento del lenguaje natural y automatización basada en IA.