conversation_search_tools.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
conversation_search_tools.py

This module combines TWO search tools over the same cleaned
doctor–patient conversation dataset:

1. Semantic (vector) search using FAISS + embeddings.
2. Keyword search using simple substring matching + scoring.

It is designed to be used both:

- As a library/module for LLM tools:
    - search_conversations_semantic_tool(...)
    - search_conversations_keyword_tool(...)

- And as a local CLI for debugging:
    python conversation_search_tools.py --mode semantic
    python conversation_search_tools.py --mode keyword
"""

import argparse
import os
from typing import List, Dict, Any, Optional

import numpy as np
import pandas as pd
import faiss

try:
    from openai import OpenAI
    client = OpenAI()
except ImportError:
    client = None


# Embedding model name (must match the one used to build the FAISS index)
EMBEDDING_MODEL = "text-embedding-3-small"

# Global caches to avoid reloading large files on every tool call
_GLOBAL_DF: Optional[pd.DataFrame] = None
_GLOBAL_DATA_PATH: Optional[str] = None

_GLOBAL_INDEX: Optional[faiss.Index] = None
_GLOBAL_INDEX_PATH: Optional[str] = None


# ======================= Data / index loading =======================

def _load_data_internal(data_path: str) -> pd.DataFrame:
    """
    Low-level function to load the cleaned CSV file.
    It does NOT enforce keyword-specific columns here; those are checked
    in the keyword tool function.
    """
    if not os.path.exists(data_path):
        raise FileNotFoundError(f"Data CSV not found: {data_path}")

    df = pd.read_csv(data_path)

    # Base required columns (used by both tools)
    base_required_cols = [
        "conversation_id",
        "description",
        "patient_text",
        "doctor_text",
    ]
    for col in base_required_cols:
        if col not in df.columns:
            raise ValueError(
                f"Required column '{col}' not in CSV. "
                f"Available columns: {list(df.columns)}"
            )

    # Keep row order consistent with whatever was used to build the index
    df = df.reset_index(drop=True)
    return df


def _ensure_data_loaded(data_path: str) -> None:
    """
    Ensure that the global DataFrame is loaded into memory.
    Reload if the path changes.
    """
    global _GLOBAL_DF, _GLOBAL_DATA_PATH

    if _GLOBAL_DF is None or _GLOBAL_DATA_PATH != data_path:
        _GLOBAL_DF = _load_data_internal(data_path)
        _GLOBAL_DATA_PATH = data_path


def _load_index_internal(index_path: str) -> faiss.Index:
    """
    Low-level function to load the FAISS index from disk.
    """
    if not os.path.exists(index_path):
        raise FileNotFoundError(f"FAISS index file not found: {index_path}")
    index = faiss.read_index(index_path)
    return index


def _ensure_index_loaded(index_path: str) -> None:
    """
    Ensure that the global FAISS index is loaded into memory.
    Reload if the path changes.
    """
    global _GLOBAL_INDEX, _GLOBAL_INDEX_PATH

    if _GLOBAL_INDEX is None or _GLOBAL_INDEX_PATH != index_path:
        _GLOBAL_INDEX = _load_index_internal(index_path)
        _GLOBAL_INDEX_PATH = index_path


# ======================= Embedding helper =======================

def embed_query(query: str) -> np.ndarray:
    """
    Convert a text query into an embedding vector (float32 numpy array).

    By default this uses OpenAI embeddings. You can replace this with any
    other embedding backend as long as you keep the same dimension and
    normalization as when the FAISS index was built.
    """
    if client is None:
        raise RuntimeError(
            "OpenAI client not available. "
            "Install `openai` and set OPENAI_API_KEY, or modify "
            "embed_query() to use your own embedding model."
        )

    resp = client.embeddings.create(
        model=EMBEDDING_MODEL,
        input=[query]
    )
    emb = np.array(resp.data[0].embedding, dtype="float32")
    # Normalize so that inner product approximates cosine similarity
    faiss.normalize_L2(emb.reshape(1, -1))
    return emb


# ======================= Semantic search core =======================

def _semantic_search_core(
    index: faiss.Index,
    df: pd.DataFrame,
    query: str,
    top_k: int = 5,
) -> List[Dict[str, Any]]:
    """
    Run vector search in FAISS to find conversations semantically
    similar to the query.
    """
    if not query:
        return []

    q_emb = embed_query(query)
    q_emb = q_emb.reshape(1, -1)

    scores, indices = index.search(q_emb, top_k)
    scores = scores[0]
    indices = indices[0]

    results: List[Dict[str, Any]] = []
    for idx, score in zip(indices, scores):
        if idx < 0:
            continue
        row = df.iloc[idx]
        results.append(
            {
                "conversation_id": str(row["conversation_id"]),
                "description": str(row.get("description", "")),
                "patient_text": str(row.get("patient_text", "")),
                "doctor_text": str(row.get("doctor_text", "")),
                "score": float(score),
            }
        )
    return results


# ======================= Keyword search core =======================

def _keyword_search_core(
    df: pd.DataFrame,
    query: str,
    top_k: int = 5,
) -> List[Dict[str, Any]]:
    """
    Perform simple keyword-based search over the "text_for_keyword_lower"
    column, then score and rank results.

    Ranking priorities:
        1. Whether patient_text contains the query (case-insensitive).
        2. Whether doctor_text contains the query (case-insensitive).
        3. Shorter text_for_keyword is ranked slightly higher.
    """
    if not query:
        return []

    required_cols = [
        "text_for_keyword",
        "text_for_keyword_lower",
    ]
    for col in required_cols:
        if col not in df.columns:
            raise ValueError(
                f"Required column '{col}' for keyword search is missing. "
                f"Available columns: {list(df.columns)}"
            )

    q = query.lower()

    mask = df["text_for_keyword_lower"].str.contains(q, na=False)
    hits = df[mask].copy()

    if hits.empty:
        return []

    # Base score column
    hits["score"] = 0.0

    # +2 if patient_text contains the query
    hits.loc[
        hits["patient_text"].str.lower().str.contains(q, na=False),
        "score"
    ] += 2.0

    # +1 if doctor_text contains the query
    hits.loc[
        hits["doctor_text"].str.lower().str.contains(q, na=False),
        "score"
    ] += 1.0

    # Length penalty: shorter text_for_keyword is preferred
    hits["length_penalty"] = hits["text_for_keyword"].str.len()

    hits = hits.sort_values(
        by=["score", "length_penalty"],
        ascending=[False, True],
    ).head(top_k)

    results: List[Dict[str, Any]] = []
    for _, row in hits.iterrows():
        results.append(
            {
                "conversation_id": str(row["conversation_id"]),
                "description": str(row.get("description", "")),
                "patient_text": str(row.get("patient_text", "")),
                "doctor_text": str(row.get("doctor_text", "")),
                "score": float(row["score"]),
            }
        )
    return results


# ======================= PUBLIC TOOL FUNCTIONS =======================

def search_conversations_semantic_tool(
    query: str,
    top_k: int = 5,
    data_path: str = "conversations_clean.csv",
    index_path: str = "conversation_vectors.index",
) -> List[Dict[str, Any]]:
    """
    LLM TOOL #1: Semantic (vector) search.

    Args:
        query: User's natural-language question (any language).
        top_k: Number of most similar conversations to retrieve.
        data_path: Path to the cleaned conversations CSV file.
        index_path: Path to the FAISS index file.

    Returns:
        A list of dicts, each with:
            - conversation_id: str
            - description: str
            - patient_text: str
            - doctor_text: str
            - score: float (similarity score; larger = more similar)
    """
    if not query or not query.strip():
        return []

    _ensure_data_loaded(data_path)
    _ensure_index_loaded(index_path)

    assert _GLOBAL_DF is not None
    assert _GLOBAL_INDEX is not None

    return _semantic_search_core(
        index=_GLOBAL_INDEX,
        df=_GLOBAL_DF,
        query=query.strip(),
        top_k=top_k,
    )


def search_conversations_keyword_tool(
    query: str,
    top_k: int = 5,
    data_path: str = "conversations_clean.csv",
) -> List[Dict[str, Any]]:
    """
    LLM TOOL #2: Keyword search.

    Args:
        query: User's keyword query or phrase (any language).
        top_k: Number of top results to return.
        data_path: Path to the cleaned conversations CSV file.

    Returns:
        A list of dicts, each with:
            - conversation_id: str
            - description: str
            - patient_text: str
            - doctor_text: str
            - score: float (simple keyword-based score)
    """
    if not query or not query.strip():
        return []

    _ensure_data_loaded(data_path)
    assert _GLOBAL_DF is not None

    return _keyword_search_core(
        df=_GLOBAL_DF,
        query=query.strip(),
        top_k=top_k,
    )


# ======================= CLI helpers (optional) =======================

def _pretty_print_results(results: List[Dict[str, Any]], title: str = "Results") -> None:
    if not results:
        print("No results found.")
        return

    print(f"\n=== {title} ===")
    for i, item in enumerate(results, start=1):
        print(f"\n[{i}] conversation_id = {item['conversation_id']}")
        print(f"Score: {item['score']:.4f}")
        if item["description"]:
            print(f"Description: {item['description']}")
        print(f"Patient: {item['patient_text']}")
        print(f"Doctor: {item['doctor_text']}")
    print(f"\n{'=' * 30}\n")


def main():
    parser = argparse.ArgumentParser(
        description=(
            "Combined search tools over cleaned doctor-patient conversations. "
            "Mode can be 'semantic' (vector search) or 'keyword'."
        )
    )
    parser.add_argument(
        "--mode",
        type=str,
        choices=["semantic", "keyword"],
        default="semantic",
        help="Search mode: 'semantic' (vector FAISS) or 'keyword'. Default: semantic",
    )
    parser.add_argument(
        "--data",
        type=str,
        default="conversations_clean.csv",
        help="Path to cleaned CSV file. Default: conversations_clean.csv",
    )
    parser.add_argument(
        "--index",
        type=str,
        default="conversation_vectors.index",
        help="Path to FAISS index file (semantic mode only).",
    )
    parser.add_argument(
        "--top_k",
        type=int,
        default=5,
        help="Number of top results to show. Default: 5",
    )
    parser.add_argument(
        "--query",
        type=str,
        default=None,
        help="Optional single query (non-interactive). "
             "If omitted, run in interactive loop.",
    )

    args = parser.parse_args()

    _ensure_data_loaded(args.data)
    if args.mode == "semantic":
        _ensure_index_loaded(args.index)

    if args.query:
        # Non-interactive: single query
        if args.mode == "semantic":
            results = search_conversations_semantic_tool(
                query=args.query,
                top_k=args.top_k,
                data_path=args.data,
                index_path=args.index,
            )
            _pretty_print_results(results, title="Semantic Search Results")
        else:
            results = search_conversations_keyword_tool(
                query=args.query,
                top_k=args.top_k,
                data_path=args.data,
            )
            _pretty_print_results(results, title="Keyword Search Results")
        return

    # Interactive loop
    print(f"{args.mode.capitalize()} search is ready.")
    print("Type your query and press Enter to search.")
    print("Type 'q' or empty line to exit.\n")

    while True:
        try:
            query = input("Query> ").strip()
        except (KeyboardInterrupt, EOFError):
            print("\nExiting.")
            break

        if query == "" or query.lower() == "q":
            print("Bye.")
            break

        if args.mode == "semantic":
            results = search_conversations_semantic_tool(
                query=query,
                top_k=args.top_k,
                data_path=args.data,
                index_path=args.index,
            )
            _pretty_print_results(results, title="Semantic Search Results")
        else:
            results = search_conversations_keyword_tool(
                query=query,
                top_k=args.top_k,
                data_path=args.data,
            )
            _pretty_print_results(results, title="Keyword Search Results")


if __name__ == "__main__":
    main()