async def query(
    query: str,
    filters: Optional[Dict[str, Any]] = None,
    k: int = 4,
    min_score: float = 0.0,
    max_tokens: Optional[int] = None,
    temperature: Optional[float] = None,
    use_colpali: bool = True,
    use_reranking: Optional[bool] = None,
    graph_name: Optional[str] = None,
    hop_depth: int = 1,
    include_paths: bool = False,
    prompt_overrides: Optional[Union[QueryPromptOverrides, Dict[str, Any]]] = None,
    folder_name: Optional[Union[str, List[str]]] = None,
    folder_depth: Optional[int] = None,
    chat_id: Optional[str] = None,
    schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
    llm_config: Optional[Dict[str, Any]] = None,
    padding: int = 0,
) -> CompletionResponse

from morphik import AsyncMorphik

async with AsyncMorphik() as db:
    response = await db.query(
        "What are the key findings about customer satisfaction?",
        filters={"department": "research"},
        temperature=0.7
    )

    nested = await db.query(
        "List open design questions",
        folder_name="/projects/alpha",
        folder_depth=-1,
        k=6,
    )
    
    print(response.completion)
    
    # Print the sources used for the completion
    for source in response.sources:
        print(f"Document ID: {source.document_id}, Chunk: {source.chunk_number}, Score: {source.score}")

from morphik import AsyncMorphik

async with AsyncMorphik() as db:
    # Knowledge graph enhanced query
    kg_response = await db.query(
        "How does product X relate to customer segment Y?",
        graph_name="market_graph",
        hop_depth=2,
        include_paths=True
    )
    
    print(kg_response.completion)
    
    # If include_paths=True, you can inspect the graph paths
    if kg_response.metadata and "graph" in kg_response.metadata:
        for path in kg_response.metadata["graph"]["paths"]:
            print(" -> ".join(path))

from morphik import AsyncMorphik
from morphik.models import QueryPromptOverride, EntityExtractionPromptOverride, QueryPromptOverrides

async with AsyncMorphik() as db:
    # Example with both query and entity extraction customization
    response = await db.query(
        "How does the medication affect diabetes?",
        graph_name="medical_graph",
        prompt_overrides=QueryPromptOverrides(
            # Customize how responses are generated
            query=QueryPromptOverride(
                prompt_template="Provide a concise, medically accurate answer: {question}\n\nContext:\n{context}\n\nAnswer:"
            ),
            # Customize entity extraction
            entity_extraction=EntityExtractionPromptOverride(
                examples=[
                    {"label": "Insulin", "type": "MEDICATION"},
                    {"label": "Diabetes", "type": "CONDITION"}
                ]
            )
        )
    )
    
    print(response.completion)

from morphik import AsyncMorphik

async with AsyncMorphik() as db:
    # Use GPT-4 for a specific query
    response = await db.query(
        "What are the key findings?",
        llm_config={
            "model": "gpt-4",
            "api_key": "sk-...",
            "base_url": "https://api.openai.com/v1",
            "temperature": 0.7,
            "max_tokens": 2000
        }
    )
    
    print(response.completion)
    
    # Use Claude for another query
    response = await db.query(
        "Summarize the research findings",
        llm_config={
            "model": "claude-3-opus-20240229",
            "api_key": "your-anthropic-key"
        }
    )
    
    print(response.completion)

from morphik import AsyncMorphik
from pydantic import BaseModel
from typing import List

# Define the desired output structure
class ResearchFindings(BaseModel):
    main_finding: str
    supporting_evidence: List[str]
    limitations: List[str]

async with AsyncMorphik() as db:
    response = await db.query(
        "Summarize the key research findings from these documents",
        filters={"department": "research"},
        schema=ResearchFindings
    )

    # Check if the completion is a dictionary (structured output)
    if isinstance(response.completion, dict):
        try:
            # Parse the dictionary into the Pydantic model
            findings = ResearchFindings(**response.completion)
            print(f"Main finding: {findings.main_finding}")
            print("Supporting evidence:")
            for evidence in findings.supporting_evidence:
                print(f"- {evidence}")
            print("Limitations:")
            for limitation in findings.limitations:
                print(f"- {limitation}")
        except Exception as e:
            print(f"Error parsing structured output: {e}")
            # Fallback: print the raw dictionary
            print(response.completion)
    elif isinstance(response.completion, str):
        # Fallback to text completion
        print(response.completion)