from praisonaiagents.knowledge.rerankers import (
    RerankResult,
    RerankerProtocol,
    RerankerRegistry,
    get_reranker_registry,
    SimpleReranker
)

# Use built-in simple reranker (no external deps)
reranker = SimpleReranker()

results = reranker.rerank(
    query="Python programming",
    documents=["Python tutorial", "Java guide", "Python best practices"],
    top_k=2
)

for result in results:
    print(f"{result.text} (score: {result.score})")

@dataclass
class RerankResult:
    text: str
    score: float
    original_index: int
    metadata: Dict[str, Any] = field(default_factory=dict)

class RerankerProtocol(Protocol):
    name: str
    
    def rerank(
        self,
        query: str,
        documents: List[str],
        top_k: Optional[int] = None,
        **kwargs
    ) -> List[RerankResult]:
        """Rerank documents by relevance to query."""
        ...

from praisonaiagents.knowledge.rerankers import SimpleReranker

reranker = SimpleReranker()

results = reranker.rerank(
    query="machine learning",
    documents=[
        "Deep learning tutorial",
        "Cooking recipes",
        "Machine learning basics"
    ],
    top_k=2
)
# Returns: ["Machine learning basics", "Deep learning tutorial"]

from praisonaiagents.knowledge.rerankers import get_reranker_registry

registry = get_reranker_registry()

# List available rerankers
rerankers = registry.list_rerankers()  # ['simple', 'llm', ...]

# Get reranker by name
reranker = registry.get("simple")

# Register custom reranker
registry.register("custom", MyReranker)

from praisonaiagents import Agent, Knowledge

# Configure reranker
agent = Agent(
    instructions="You are a helpful assistant",
    knowledge=["./docs/"],
    knowledge_config={
        "reranker": "simple",  # or "llm", "cross_encoder", "cohere"
        "rerank_top_k": 5
    }
)

response = agent.chat("What is the best approach?")

from praisonaiagents.knowledge.rerankers import (
    RerankResult,
    get_reranker_registry
)
from typing import List, Optional

class MyReranker:
    name = "my_reranker"
    
    def rerank(
        self,
        query: str,
        documents: List[str],
        top_k: Optional[int] = None,
        **kwargs
    ) -> List[RerankResult]:
        # Custom scoring logic
        scored = []
        for i, doc in enumerate(documents):
            score = self._compute_score(query, doc)
            scored.append(RerankResult(
                text=doc,
                score=score,
                original_index=i
            ))
        
        # Sort by score descending
        scored.sort(key=lambda x: x.score, reverse=True)
        
        if top_k:
            scored = scored[:top_k]
        
        return scored
    
    def _compute_score(self, query: str, doc: str) -> float:
        # Your scoring logic
        ...

# Register
registry = get_reranker_registry()
registry.register("my_reranker", MyReranker)

from praisonaiagents.knowledge.rerankers import get_reranker_registry

# Get LLM reranker (requires OpenAI API key)
registry = get_reranker_registry()
llm_reranker = registry.get("llm", model="gpt-4o-mini")

results = llm_reranker.rerank(
    query="How to deploy to production?",
    documents=documents,
    top_k=5
)