使用MongoDB进行代理良率分析

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]

# 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"
    }}
)

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

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]

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

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

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

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