LangChain integration

import asyncio
import os
from langchain_catchall import AsyncCatchAllClient

async def process_multiple_queries():
    """Submit multiple searches concurrently."""
    client = AsyncCatchAllClient(api_key=os.environ["CATCHALL_API_KEY"])

    queries = [
        "Technology company acquisitions and mergers",
        "Healthcare and biotech company IPO filings",
        "Retail company bankruptcy filings and restructuring",
    ]

    try:
        # Submit all jobs concurrently
        job_ids = await asyncio.gather(*[
            client.submit_job(query) for query in queries
        ])

        print(f"Submitted {len(job_ids)} jobs")

        # Wait for all completions
        await asyncio.gather(*[
            client.wait_for_completion(job_id) for job_id in job_ids
        ])

        # Retrieve all results
        results = await asyncio.gather(*[
            client.get_all_results(job_id) for job_id in job_ids
        ])

        # Process results
        for query, result in zip(queries, results):
            print(f"\n{query}: {result.valid_records} records")

    except TimeoutError as e:
        print(f"One or more jobs timed out: {e}")
    except Exception as e:
        print(f"Error processing queries: {e}")
        raise

if __name__ == "__main__":
    asyncio.run(process_multiple_queries())

CATCHALL_AGENT_PROMPT = """You are a News Research Assistant powered by CatchAll.

Your workflow is strictly defined:

1. SEARCH: Use `catchall_search_data` to get a broad initial dataset (e.g., 'Find all US office openings').
   - WARNING: This tool takes 15 minutes. NEVER call it twice in a row.
   - After searching, STOP and return what you found. WAIT for the user's next question.
   - DO NOT automatically analyze or summarize unless explicitly asked.
   
2. ANALYZE: Use `catchall_analyze_data` ONLY when the user asks a follow-up question.
   - FILTERING & SORTING: 'Show me only Florida deals', 'Sort by date', 'Find top 3'.
   - AGGREGATION: 'Group by state', 'Count by industry'.
   - QA: 'What are the main trends?', 'Summarize key findings'.
   
CRITICAL RULES:
- After a search completes, report the number of results found and STOP. Wait for user input.
- ONLY call analyze_data when the user explicitly asks a follow-up question.
- If user says "Find X", just search and report results. If they say "Summarize Y" or "Show me Z", then analyze.
- Never use `catchall_search_data` to filter. Always use `catchall_analyze_data` for filtering.
- If the user asks for a subset of data (like 'only Florida deals'), assume it is ALREADY in your search results.
- Only use `catchall_search_data` if the user explicitly asks for a 'new search' or a completely different topic.
"""

import os
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
from langchain.messages import SystemMessage
from langchain_catchall import CatchAllTools, CATCHALL_AGENT_PROMPT

def run_interactive_agent(): """Run an interactive research agent with
conversation history."""

    try:
        # Setup
        api_key = os.environ.get("CATCHALL_API_KEY")
        if not api_key:
            raise ValueError("CATCHALL_API_KEY environment variable not set")

        llm = ChatOpenAI(model="gpt-4o", temperature=0)
        toolkit = CatchAllTools(api_key=api_key, llm=llm, verbose=True)
        tools = toolkit.get_tools()

        # Create agent
        agent = create_react_agent(model=llm, tools=tools)
        messages = [SystemMessage(content=CATCHALL_AGENT_PROMPT)]

        print("Research Agent Ready!")
        print("Type 'quit' to exit\n")

        while True:
            try:
                # Get user input
                user_input = input("You: ").strip()
                if user_input.lower() == 'quit':
                    break

                if not user_input:
                    continue

                # Add user message
                messages.append(("user", user_input))

                # Get agent response
                response = agent.invoke({"messages": messages})
                assistant_message = response["messages"][-1].content

                # Add assistant message to history
                messages.append(("assistant", assistant_message))

                # Display response
                print(f"\nAgent: {assistant_message}\n")

            except KeyboardInterrupt:
                print("\nExiting...")
                break
            except Exception as e:
                print(f"\nError: {e}")
                print("Continuing...\n")

    except Exception as e:
        print(f"Failed to initialize agent: {e}")
        raise

if __name__ == "__main__":
    run_interactive_agent()

You: Find venture capital funding rounds for biotech startups

Agent: I'll search for biotech venture funding articles... [15 minutes later]
Found 47 records. Here are the top deals:

1. BioTech Corp raised $25M Series B
2. GeneTech raised $15M Series A ...

You: Show only deals over $20M

Agent: [Instantly] Based on the cached results, here are deals over $20M:

1. BioTech Corp - $25M Series B
2. MedTech Inc - $30M Series C ...

You: What's the average funding amount?

Agent: [Instantly] Analyzing the data... The average funding amount is $18.5M 
across all 47 deals.