Análisis de Rendimiento Agente con MongoDB

Incrustaciones multimodales para defectos de obleas

Esta solución utiliza el modelo voyage-multimodal-3 de Voyage AI para generar incrustaciones que combinan imágenes de defectos de oblea con contexto textual. Esto permite la búsqueda de similitud semántica tanto en patrones visuales como en texto descriptivo.

Servicio de Embedding

La EmbeddingService La clase maneja la generación de incrustaciones utilizando el cliente Voyage AI:

import voyageai
from PIL import Image
import base64
import io
class EmbeddingService:
    def __init__(self):
        self.voyage_client = voyageai.Client(api_key=os.getenv("VOYAGE_API_KEY"))
        self.multimodal_model = "voyage-multimodal-3"
        self.embedding_dimension = 1024
    async def generate_image_embedding(
        self,
        image_data: str,
        text_context: str = None
    ) -> List[float]:
        """Generate multimodal embedding from image and text."""
        # Decode base64 image to PIL Image
        image_bytes = base64.b64decode(image_data)
        pil_image = Image.open(io.BytesIO(image_bytes))
        # Combine text and image inputs
        inputs = []
        if text_context:
            inputs.append(text_context)
        inputs.append(pil_image)
        # Generate embedding
        result = self.voyage_client.multimodal_embed(
            inputs=[inputs],
            model=self.multimodal_model,
            input_type="document"
        )
        return result.embeddings[0]

Defectos en el procesamiento de obleas

Para cada documento de defecto de wafer, la pipeline realiza las siguientes acciones:

1. Genera contenido textual a partir de características observables (ID de oblea, patrón de fallos, equipo, rendimiento, descripción de oblea).

2. Obtiene la imagen del mapa de tinta desde Amazon S3.

3. Genera un embedding multimodal que combina ambas entradas.

4. Almacena el vector 1024-dimensional en el campo embedding.

# Build text from observable facts only (not suspected causes)
text_content = f"Wafer ID: {wafer['wafer_id']} "
text_content += f"Defect pattern: {wafer['defect_summary']['defect_pattern']} "
text_content += f"Equipment: {wafer['process_context']['equipment_used'][0]} "
text_content += f"Yield: {wafer['defect_summary']['yield_percentage']}%"
# Get image data
image_data = wafer["ink_map"]["thumbnail_base64"]
# Generate multimodal embedding
embedding = await embedding_service.generate_image_embedding(
    image_data=image_data,
    text_context=text_content
)
# Store in document
await db.wafer_defects.update_one(
    {"_id": wafer["_id"]},
    {"$set": {
        "embedding": embedding,
        "embedding_type": "multimodal",
        "embedding_model": "voyage-multimodal-3"
    }}
)

Índice de búsqueda vectorial

Cree un índice de búsqueda vectorial en la colección wafer_defects de MongoDB Atlas:

{
  "name": "wafer_defects_vector_search",
  "type": "vectorSearch",
  "definition": {
    "fields": [
      {
        "path": "embedding",
        "type": "vector",
        "numDimensions": 1024,
        "similarity": "cosine"
      }
    ]
  }
}

Esto permite que el Root Cause agente encuentre defectos históricos similares utilizando la búsqueda vectorial, incluso cuando la causa raíz de la nueva oblea no sea conocida.

Herramientas del agente

Las herramientas son funciones de dominio específico que permiten al agente interactuar con MongoDB Atlas. Realizan consultas de datos de sensores, ejecutan búsquedas semánticas y recuperan patrones históricos. Cada herramienta devuelve datos estructurados que el LLM analiza para generar informes RCA.

El siguiente código muestra cómo registrar una herramienta para el agente de causa raíz usando el decorador @tool de LangChain. En este ejemplo, la herramienta utiliza la búsqueda vectorial para encontrar patrones de defectos de oblea similares.

from langchain_core.tools import tool
@tool
async def query_wafer_info(
    wafer_id: str,
    include_similar_patterns: bool = True,
    similarity_limit: int = 3
) -> Dict[str, Any]:
    """
    Get wafer defect details and find similar historical patterns.
    Returns the wafer data plus similar past defects with known root causes.
    """
    db = _get_db()
    wafer = await db.wafer_defects.find_one({"wafer_id": wafer_id})
    if not wafer:
        return {"error": f"Wafer {wafer_id} not found"}
    similar_patterns = None
    if include_similar_patterns and "embedding" in wafer:
        pipeline = [
            {
                "$vectorSearch": {
                    "index": "wafer_defects_vector_index",
                    "path": "embedding",
                    "queryVector": wafer["embedding"],
                    "numCandidates": 100,
                    "limit": similarity_limit + 1
                }
            },
            {"$match": {"wafer_id": {"$ne": wafer_id}}},
            {"$addFields": {"similarity_score": {"$meta": "vectorSearchScore"}}},
            {"$limit": similarity_limit}
        ]
        results = await db.wafer_defects.aggregate(pipeline).to_list(length=None)
        similar_patterns = [
            {
                "wafer_id": r.get("wafer_id"),
                "description": r.get("description"),
                "root_cause": r.get("root_cause"),
                "similarity_score": round(r.get("similarity_score", 0), 4)
            }
            for r in results
        ]
    return {
        "wafer": wafer,
        "similar_historical_patterns": similar_patterns
    }
# Tool registry
TOOLS = [query_alerts, query_wafer_info, query_time_series_data, vector_search_knowledge_base]

El agente de causa raíz utiliza las siguientes herramientas para investigar desviaciones:

1. query_alerts

   • Recupera alertas recientes filtradas por equipo, gravedad o período de tiempo.

   • Retorna los detalles de la infracción, obleas afectadas y datos de sensores fuente.

2. query_wafer_info

   • Obtiene detalles de defectos de oblea incluyendo porcentaje de rendimiento, patrón de defectos y gravedad.

   • Realiza una búsqueda vectorial multimodal para encontrar defectos históricos similares con causas raíz conocidas.

3. query_time_series_data

   • Consulta la telemetría de los sensores en una ventana de tiempo específica.

   • Devuelve estadísticas agregadas (mín, máx, prom) para reducir el uso de tokens.

   • Identifica anomalías de sensores correlacionadas con eventos de defectos.

4. vector_search_knowledge_base

   • Busca informes RCA históricos y documentación técnica mediante incrustaciones semánticas.

   • Devuelve documentos coincidentes con títulos, causas raíz y acciones correctivas.

   • Ayuda al agente a consultar soluciones anteriores para fallos similares.

Puedes ampliar este conjunto de herramientas para adaptarlo a los procesos de la fábrica. Por ejemplo, agrega herramientas para consultar los registros de mantenimiento de equipos, verificar los parámetros de receta o recuperar las notas de turno del operador.

Memoria de agente

Para que los agentes funcionen de manera eficaz, necesitan tener memoria para almacenar el contexto y los pasos de razonamiento. Esta capacidad permite a los agentes:

• Mantener la continuidad dentro de una investigación.

• Recuerda los pasos anteriores y los resultados de las herramientas.

• Construye contexto entre las interacciones de los usuarios.

En esta arquitectura, MongoDB Atlas almacena toda la memoria del agente. La memoria consta de los siguientes tipos:

Memoria a corto plazo: Almacena el estado intermedio a medida que el agente avanza en la investigación. Esta memoria asegura que si un proceso se ve interrumpido, pueda reanudarse sin perder progreso. Las siguientes colecciones almacenan este tipo de memoria:

• checkpoints: Captura el estado del agente en cada paso de razonamiento.

• checkpoint_writes: Registra las llamadas a la herramienta y sus resultados.

Memoria a largo plazo: almacena datos históricos que informan las investigaciones actuales. Los agentes recuperan estos datos usando una búsqueda vectorial, asegurando que el contexto histórico impulse el razonamiento. Las colecciones incluyen:

• wafer_defects: Datos de inspección de obleas con incrustaciones multimodales para búsqueda de similitud.

• historical_knowledge: Informes RCA, documentación técnica y conocimiento tribal.

• alerts: Alertas activas y resueltas con detalles de violación y datos de origen.

• process_sensor_ts: serie de tiempo de telemetría de sensores para análisis de correlación.

Para configurar la memoria a corto plazo, utiliza la clase MongoDBSaver de LangGraph. Esta clase escribe el progreso del agente en las colecciones checkpoints de la siguiente manera:

from langgraph.checkpoint.mongodb import MongoDBSaver
from pymongo import MongoClient
mongo_client = MongoClient(os.getenv("MONGODB_URI"))
checkpointer = MongoDBSaver(mongo_client, "smf-yield-defect")

Esta configuración habilita las capacidades de memoria y tolerancia a fallos para el agente de causa raíz.

grafo de estados del agente

Un grafo de estados modela los flujos de trabajo como nodos y aristas. Cada nodo representa un paso de razonamiento, una llamada a una herramienta o un punto de control. Los bordes definen las transiciones entre estos pasos. Los grafos de estado hacen que los flujos de trabajo sean explícitos, repetibles y resilientes.

En esta solución, LangGraph permite que el grafo de estado coordine la herramienta Root Cause Agent y sus herramientas. El agente sigue un patrón ReAct (Razonamiento + Acción):

1. Razón: El LLM analiza el estado actual y decide la siguiente acción.

2. Actuar: El agente llama a una herramienta para recuperar datos de MongoDB.

3. Observa: El agente procesa el resultado de la herramienta y actualiza su razonamiento.

4. Repetir: el ciclo continúa hasta que el agente tiene pruebas suficientes.

Esta arquitectura garantiza las siguientes capacidades:

• El agente puede bifurcarse en función de los hallazgos, como patrones similares encontrados frente a la ausencia de coincidencias.

• Cada paso guarda en la memoria y lee automáticamente de ella.

• Los ingenieros pueden retomar conversaciones o auditar la cadena de razonamiento.

El siguiente código compila un agente ReAct con punto de control de MongoDB:

from langgraph.prebuilt import create_react_agent
from langchain_aws import ChatBedrock
async def create_rca_agent():
    """Create LangGraph agent with MongoDB checkpointing."""
    # Initialize LLM
    llm = ChatBedrock(
        model_id="anthropic.claude-3-5-sonnet-20241022-v2:0",
        region_name=os.getenv("AWS_REGION", "us-east-1")
    )
    # Initialize MongoDB checkpointer
    mongo_client = MongoClient(os.getenv("MONGODB_URI"))
    checkpointer = MongoDBSaver(mongo_client, "smf-yield-defect")
    # System prompt
    system_prompt = """You are an expert semiconductor yield engineer.
    When investigating alerts:
    1. First, query the alert details
    2. Get wafer defect information and similar historical patterns
    3. Query sensor data around the alert time
    4. Search the knowledge base for similar RCA reports
    5. Synthesize findings into a structured root cause analysis
    Always cite evidence from the tools."""
    # Create agent
    agent = create_react_agent(
        model=llm,
        tools=TOOLS,
        checkpointer=checkpointer,
        prompt=system_prompt
    )
    return agent

Con esta configuración, puedes rastrear, reanudar y depurar todo el flujo de trabajo de investigación.

Flujo de trabajo de extremo a extremo

El siguiente explica cómo el sistema procesa una excursión:

Puedes ampliar y personalizar este flujo de trabajo con las siguientes capacidades:

• Remediación automatizada: Activar el aislamiento del equipo o los ajustes de la receta basándose en los hallazgos del Análisis de causa raíz (RCA).

• Alertas predictivas: Utilice patrones históricos para advertir antes de que se violen los umbrales.

• Correlación de múltiples herramientas: Añade herramientas para {query} parámetros de recetas, registros de cámaras o cronogramas de mantenimiento.

Como las herramientas, memoria y orquestación de grafos son modulares, puede agregar nuevas capacidades sin interrumpir los flujos de trabajo existentes.

Colecciones principales

Esta solución utiliza las siguientes colecciones para almacenar datos:

sensor_events: Eventos de sensores en tiempo real para la supervisión de Change Stream. Esta colección regular permite que el Sistema de Detección de Excursiones vigile las violaciones de los umbrales en tiempo real.

alerts: Desviaciones activas y violaciones de umbral que activan el Root Cause Agent. Cada alerta captura los detalles de la violación, la oblea afectada y los datos del sensor de origen. Las transiciones de estado de "abierto" a "reconocido" a "resuelto".

wafer_defectsDatos de inspección de obleas con incrustaciones multimodales para la búsqueda semántica. Cada documento incluye patrones de defectos, porcentajes de rendimiento, niveles de gravedad y la incrustación combinada de imagen y texto generada por Voyage IA.

historical_knowledge- RCA informes y documentación técnica almacenados con incrustaciones vectoriales. Los agentes buscan en esta colección para encontrar incidentes pasados similares, procedimientos de resolución de problemas y acciones correctivas comprobadas.

process_context: Metadatos del proceso de fabricación, incluidos los parámetros de la receta, configuraciones del equipo y valores base para el análisis de correlación.

checkpoints: El estado del agente es capturado en cada paso del razonamiento por el MongoDBSaver de LangGraph para habilitar la persistencia de la conversación, la reanudación de sesiones y las rutas de auditoría.

process_sensor_ts: Procesar telemetría de sensores almacenada como una colección de series de tiempo para un análisis histórico eficiente. Las colecciones de series de tiempo almacenan y consultan de manera eficiente millones de lecturas. Conservan metadatos contextuales, como ID de equipo, ID de lote y etapa del proceso.

El siguiente ejemplo muestra un documento de muestra de la colección process_sensor_ts:

{
  "timestamp": {
    "$date": "2025-01-24T10:30:00.000Z"
  },
  "equipment_id": "CMP_TOOL_01",
  "metrics": {
    "particle_count": 1234,
    "temperature": 68.5,
    "rf_power": 1502.3,
    "chamber_pressure": 5.2
  },
  "metadata": {
    "lot_id": "LOT_2025_001",
    "wafer_id": "W_004_16",
    "process_step": "Oxide CMP"
  }
}

El documento de la serie de tiempo incluye los siguientes campos:

• timestamp: La marca de tiempo de la lectura

• equipment_id: El identificador de la herramienta de origen

• metricsValores numéricos del sensor para recuento de partículas, temperatura, potencia de RF y presión de la cámara

• metadataEtiquetas contextuales para lote, oblea y paso de proceso

El siguiente ejemplo muestra un documento de muestra de la colección wafer_defects:

{
  "_id": "W_CMP_001",
  "wafer_id": "W_CMP_001",
  "lot_id": "LOT_2025_001",
  "inspection_timestamp": { "$date": "2025-01-24T10:30:00Z" },
  "description": "Edge-concentrated particle contamination from slurry degradation",
  "defect_summary": {
    "defect_pattern": "edge_cluster",
    "severity": "critical",
    "yield_percentage": 72.5,
    "failed_dies": 22,
    "total_dies": 80
  },
  "process_context": {
    "equipment_used": ["CMP_TOOL_01"],
    "last_process_step": "Oxide CMP",
    "recipe_id": "CMP_STD_01",
    "slurry_batch": "SLR-2025-0142"
  },
  "ink_map": {
    "thumbnail_base64": "iVBORw0KGgo...",
    "thumbnail_size": { "width": 200, "height": 200 },
    "full_image_url": "s3://bucket/wafers/W_CMP_001.png"
  },
  "embedding": [0.123, -0.456, ...]
}

El documento de defectos de oblea incluye los siguientes campos:

• wafer_id y lot_id: Vincula el defecto al contexto de producción

• description: Contiene el análisis de la causa raíz de los wafers históricos

• defect_summary: Captura el tipo de patrón, la gravedad, el impacto en el rendimiento y los conteos de descarte

• process_context: Rastrea el equipo, la receta y los materiales para el análisis de correlación

• ink_map: Almacena la visualización del mapa de obleas (miniatura para mostrar, S3 URL para la imagen completa)

• embeddingContiene el vector multimodal de 1024dimensiones para la búsqueda de similitud