Análisis de rendimiento de Agentic con MongoDB

Incrustaciones multimodales para defectos en obleas

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

Servicio de incrustación

El EmbeddingService La clase maneja la generación de incrustaciones mediante 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]

Procesamiento de defectos en obleas

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

1. Crea contenido de texto a partir de características observables (identificación de la oblea, patrón de defectos, equipo, rendimiento, descripción de la oblea).

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

3. Genera una incrustación multimodal combinando ambas entradas.

4. Almacena el vector de dimensión 1024en 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 de vectores

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 agente de causa raíz encuentre defectos históricos similares mediante la búsqueda vectorial, incluso cuando la nueva oblea no tiene una causa raíz conocida.

Herramientas del agente

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

El siguiente código muestra cómo registrar una herramienta para el Agente de Causa Raíz mediante el decorador @tool de LangChain. En este ejemplo, la herramienta utiliza la búsqueda vectorial para encontrar patrones de defectos de obleas 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 las excursiones:

1. query_alerts

   • Recupera alertas recientes filtradas por equipo, gravedad o ventana de tiempo.

   • Devuelve detalles de la violación, obleas afectadas y datos del sensor de origen.

2. query_wafer_info

   • Obtiene detalles de los defectos de la oblea, incluido el porcentaje de rendimiento, el patrón del defecto y la 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 del sensor alrededor de una ventana de tiempo específica.

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

   • Identifica anomalías del sensor correlacionadas con eventos defectuosos.

4. vector_search_knowledge_base

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

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

   • Ayuda al agente a consultar soluciones pasadas para fallas similares.

Puede ampliar este conjunto de herramientas para adaptarlo a los procesos de su fábrica. Por ejemplo, agregue herramientas para consultar registros de mantenimiento de equipos, verificar parámetros de recetas o recuperar notas de turnos de operadores.

Memoria de agente

Para que los agentes trabajen eficazmente, necesitan memoria para almacenar el contexto y los pasos de razonamiento. Esta capacidad les permite:

• Mantener la continuidad dentro de una investigación.

• Recordar pasos anteriores y resultados de herramientas.

• Crear contexto a través de las interacciones del usuario.

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 garantiza que, si un proceso se interrumpe, pueda reanudarse sin perder el progreso. Las siguientes colecciones almacenan este tipo de memoria:

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

• checkpoint_writes:Registra las llamadas a herramientas y sus salidas.

Memoria a largo plazo: Almacena datos históricos que fundamentan las investigaciones actuales. Los agentes recuperan estos datos mediante la búsqueda vectorial, lo que garantiza 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 de RCA, documentación técnica y conocimiento tribal.

• alerts:Alertas activas y resueltas con detalles de violaciones y datos de origen.

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

Para configurar la memoria a corto plazo, utilice 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 capacidades de memoria y tolerancia a fallas para el Agente de Causa Raíz.

Gráfico de estado 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. Las aristas definen las transiciones entre estos pasos. Los grafos de estados hacen que los flujos de trabajo sean explícitos, repetibles y resilientes.

En esta solución, LangGraph permite que el grafo de estados coordine el Agente de Causa Raíz 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 próxima acción.

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

3. Observar: El agente procesa la salida de la herramienta y actualiza su razonamiento.

4. Repetir: El ciclo continúa hasta que el agente tenga suficiente evidencia.

Esta arquitectura garantiza las siguientes capacidades:

• El agente puede ramificarse en función de los hallazgos, como por ejemplo, patrones similares encontrados versus ninguna coincidencia.

• 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, puede rastrear, reanudar y depurar todo el flujo de trabajo de la investigación.

Flujo de trabajo de extremo a extremo

A continuación se describe cómo el sistema procesa una excursión:

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

• Remediación automatizada: active el aislamiento del equipo o ajustes de recetas según los hallazgos del 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.

Debido a que las herramientas, la memoria y la orquestación de gráficos 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_eventsEventos de sensores en tiempo real para la monitorización del flujo de cambios. Esta recopilación periódica permite al Sistema de Detección de Excursiones detectar infracciones de umbral en tiempo real.

alertsExcursiones activas y violaciones de umbral que activan el Agente de Causa Raíz. Cada alerta captura los detalles de la violación, la oblea afectada y los datos del sensor fuente. El estado cambia de "abierto" a "confirmado" y "resuelto".

wafer_defectsDatos de inspección de obleas con incrustaciones multimodales para 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 AI.

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

process_context:Metadatos del proceso de fabricación, incluidos parámetros de recetas, configuraciones de equipos y valores de referencia 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_tsLa telemetría de los sensores de proceso se almacena como una colección de series temporales para un análisis histórico eficiente. Las colecciones de series temporales almacenan y consultan eficientemente millones de lecturas. Conservan metadatos contextuales, como el ID del equipo, el ID del lote y el paso del proceso.

El siguiente ejemplo muestra un documento de muestra en 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 series temporales incluye los siguientes campos:

• timestamp:La marca de tiempo de la lectura

• equipment_id: El identificador de la herramienta de origen

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

• metadata:Etiquetas contextuales para lote, oblea y paso del proceso

El siguiente ejemplo muestra un documento de muestra en 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 defecto 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 las obleas históricas

• defect_summary:Captura el tipo de patrón, la gravedad, el impacto en el rendimiento y los recuentos de matrices.

• process_context: Realiza un seguimiento de equipos, recetas y materiales para el análisis de correlación.

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

• embedding: Contiene el vector multimodal de dimensión 1024para la búsqueda de similitud