Build a Casting Agent

# Face search retriever (find talent by face similarity)
face_retriever = client.retrievers.create(
    retriever_name="talent-face-search",
    namespace_id=namespace_id,
    description="Find talent by face similarity",
    input_schema={
        "properties": {
            "query_url": {"type": "url", "required": True}
        }
    },
    collection_ids=[talent_collection_id],
    stages=[
        {
            "stage_type": "filter",
            "stage_id": "feature_search",
            "parameters": {
                "feature_uri": "mixpeek://face_identity_extractor@v1/face_embedding",
                "input": {"image": "{{INPUT.query_url}}"},
                "limit": 20
            }
        }
    ],
    cache_config={"enabled": True, "ttl_seconds": 300}
)

face_retriever_id = face_retriever.retriever_id

# Scene search retriever (find ads by visual/transcript content)
scene_retriever = client.retrievers.create(
    retriever_name="ad-scene-search",
    namespace_id=namespace_id,
    description="Search ad scenes by visual content or transcript",
    input_schema={
        "properties": {
            "query_text": {"type": "text", "required": True}
        }
    },
    collection_ids=[ads_collection_id],
    stages=[
        {
            "stage_type": "filter",
            "stage_id": "feature_search",
            "parameters": {
                "feature_uri": "mixpeek://multimodal_extractor@v1/multimodal_embedding",
                "input": {"text": "{{INPUT.query_text}}"},
                "limit": 20
            }
        }
    ],
    cache_config={"enabled": True, "ttl_seconds": 300}
)

scene_retriever_id = scene_retriever.retriever_id

from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder


def search_faces(query_url: str) -> str:
    """Search talent database by face image URL."""
    results = client.retrievers.execute(
        retriever_id=face_retriever_id,
        namespace_id=namespace_id,
        inputs={"query_url": query_url},
        limit=10
    )
    formatted = []
    for r in results.results:
        score = r.score
        source = r.metadata.get("source_video_url", "unknown")
        formatted.append(f"(score: {score:.3f}) source: {source}")
    return "\n".join(formatted) if formatted else "No matching faces found."


def search_scenes(query: str) -> str:
    """Search ad archive by visual content or transcript."""
    results = client.retrievers.execute(
        retriever_id=scene_retriever_id,
        namespace_id=namespace_id,
        inputs={"query_text": query},
        limit=10
    )
    formatted = []
    for r in results.results:
        start = r.metadata.get("start_time", "?")
        end = r.metadata.get("end_time", "?")
        desc = r.metadata.get("description", "")
        transcript = r.metadata.get("transcription", "")[:100]
        formatted.append(
            f"[{start}s - {end}s] (score: {r.score:.3f}) {desc}"
            + (f" | transcript: {transcript}..." if transcript else "")
        )
    return "\n".join(formatted) if formatted else "No matching scenes found."


def check_competitor(query_url: str) -> str:
    """Check if a face appears in competitor ad campaigns."""
    results = client.retrievers.execute(
        retriever_id=competitor_retriever_id,
        namespace_id=competitor_namespace_id,
        inputs={"query_url": query_url},
        limit=10
    )
    formatted = []
    for r in results.results:
        score = r.score
        source = r.metadata.get("source_video_url", "unknown")
        conflict = "CONFLICT" if score > 0.85 else "low similarity"
        formatted.append(f"({conflict}, score: {score:.3f}) source: {source}")
    return "\n".join(formatted) if formatted else "No matches in competitor ads."


# Define tools
face_search_tool = Tool(
    name="face_search",
    description=(
        "Search the talent database by face. Input is an image URL of a face. "
        "Returns matching talent profiles with similarity scores. "
        "Use this to find which talent appeared in specific content."
    ),
    func=search_faces
)

scene_search_tool = Tool(
    name="scene_search",
    description=(
        "Search ad archive by visual content or spoken words. Input is a text query. "
        "Returns matching ad scenes with timestamps, descriptions, and transcripts. "
        "Use this to find ads matching a visual or thematic description."
    ),
    func=search_scenes
)

competitor_check_tool = Tool(
    name="competitor_check",
    description=(
        "Check if a talent's face appears in competitor ad campaigns. "
        "Input is an image URL of the talent's face. "
        "Returns matches with conflict flags (score > 0.85 = same person). "
        "Use this to detect casting conflicts before booking talent."
    ),
    func=check_competitor
)

# Build the agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system",
     "You are a casting research assistant for a performance marketing agency. "
     "You help find talent, analyze ad creative history, and detect casting conflicts. "
     "You have three tools:\n"
     "- face_search: find talent by face image\n"
     "- scene_search: find ads by visual/transcript content\n"
     "- competitor_check: check if talent appears in competitor campaigns\n\n"
     "When asked about casting conflicts, always run competitor_check. "
     "When asked to find talent for a specific type of ad, use scene_search first "
     "to find matching ads, then cross-reference faces."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_openai_tools_agent(llm, [face_search_tool, scene_search_tool, competitor_check_tool], prompt)
executor = AgentExecutor(agent=agent, tools=[face_search_tool, scene_search_tool, competitor_check_tool], verbose=True)

response = executor.invoke({
    "input": "Find me talent who appeared in high-performing outdoor ads but never in a competitor campaign"
})

print(response["output"])