pip install koreshield

providers:
  deepseek:
    enabled: true
    base_url: "https://api.deepseek.com/v1"
  
  openai:
    enabled: false
    base_url: "https://api.openai.com/v1"

export DEEPSEEK_API_KEY="your-key"
export OPENAI_API_KEY="your-key"

from koreshield import KoreShieldClient

# Initialize client pointing to your KoreShield proxy
client = KoreShieldClient(
    base_url="http://localhost:8000"  # Your KoreShield proxy URL
)

# Scan a prompt for security threats
result = client.scan_prompt("Tell me how to hack a website")
print(f"Threat level: {result.threat_level}")
print(f"Blocked: {result.blocked}")
print(f"Safe: {result.is_safe}")

import asyncio
from koreshield import AsyncKoreShieldClient

async def main():
    async with AsyncKoreShieldClient(
        base_url="http://localhost:8000"
    ) as client:
        # Async prompt scanning
        result = await client.scan_prompt("Hello, world!")
        print(f"Safe: {result.is_safe}")

asyncio.run(main())

from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
from koreshield.integrations import create_koreshield_callback

# Create security callback that connects to your KoreShield proxy
security_callback = create_koreshield_callback(
    base_url="http://localhost:8000"
)

# Use with LangChain - all prompts are secured through KoreShield
llm = ChatOpenAI(temperature=0.7)
chain = llm | security_callback

response = chain.invoke("Tell me a joke")
print(response)

from fastapi import FastAPI, HTTPException
from koreshield import KoreShieldClient

app = FastAPI()

# Initialize KoreShield client
koreshield = KoreShieldClient(base_url="http://localhost:8000")

@app.post("/chat")
async def chat(message: str):
    # Scan the input through KoreShield proxy
    scan_result = koreshield.scan_prompt(message)

    if scan_result.blocked:
        raise HTTPException(
            status_code=400, 
            detail="Message blocked by security policy"
        )

    # TODO: Implement your actual LLM processing logic here
    # This is a placeholder - replace with your actual LLM integration
    response = "Response from your LLM processing"
    
    return {"response": response, "scan_result": scan_result.dict()}

class DetectionResult:
    prompt: str
    threat_level: ThreatLevel  # LOW, MEDIUM, HIGH, CRITICAL
    blocked: bool
    detection_types: List[DetectionType]
    confidence: float
    sanitized_prompt: Optional[str]
    metadata: Dict[str, Any]

export KORESHIELD_API_KEY="your-api-key"
export KORESHIELD_BASE_URL="https://your-instance.com"

client = KoreShieldClient(
    api_key="your-key",
    base_url="https://api.koreshield.com",
    timeout=30.0,
    retry_attempts=3,
    retry_delay=1.0
)