Configuration Guide

# Anthropic Claude (Recommended)
export ANTHROPIC_API_KEY="sk-ant-..."
export ANTHROPIC_MODEL="claude-3-5-sonnet-20241022"

# OpenAI GPT
export OPENAI_API_KEY="sk-..."
export OPENAI_MODEL="gpt-4-turbo-preview"

# Qdrant settings
export QDRANT_HOST="localhost"
export QDRANT_PORT=6333
export QDRANT_COLLECTION="taxia_documents"

# Neo4j settings
export NEO4J_URI="bolt://localhost:7687"
export NEO4J_USER="neo4j"
export NEO4J_PASSWORD="your-password"

from taxia import TaxiaEngine, TaxiaConfig

config = TaxiaConfig(
    llm_provider="anthropic",
    llm_model="claude-3-5-sonnet-20241022",
    qdrant_host="localhost",
    qdrant_port=6333,
    enable_graph_rag=True,
)

engine = TaxiaEngine(config=config)

config = TaxiaConfig(
    # LLM settings
    llm_provider="anthropic",
    llm_model="claude-3-5-sonnet-20241022",
    llm_temperature=0.1,
    llm_max_tokens=4000,

    # Vector search
    qdrant_host="localhost",
    qdrant_port=6333,
    qdrant_collection="taxia_docs",
    top_k=5,

    # Graph-RAG
    enable_graph_rag=True,
    neo4j_uri="bolt://localhost:7687",
    neo4j_user="neo4j",
    neo4j_password="password",

    # Logging
    log_level="INFO",
    enable_audit_trail=True,
)

llm:
  provider: anthropic
  model: claude-3-5-sonnet-20241022
  temperature: 0.1
  max_tokens: 4000

vector_search:
  host: localhost
  port: 6333
  collection: taxia_documents
  top_k: 5

graph_rag:
  enabled: true
  uri: bolt://localhost:7687
  user: neo4j
  password: password

logging:
  level: INFO
  audit_trail: true

from taxia import TaxiaEngine

engine = TaxiaEngine.from_config_file("taxia.yaml")

Average Query = 2,000 input tokens + 500 output tokens

Claude 3.5 Sonnet:
- Input: (2,000 / 1,000,000) × $3.00 = $0.006
- Output: (500 / 1,000,000) × $15.00 = $0.0075
- Total: ~$0.014 per query

Daily estimates (1,000 queries):
- $14/day = $420/month

Daily estimates (100 queries):
- $1.40/day = $42/month

LLM API (Claude 3.5 Sonnet): $42/month
Infrastructure (self-hosted): $0/month
Total: ~$42/month ($0.014 per query)

LLM API (Claude 3.5 Sonnet): $420/month
Infrastructure (cloud): $50/month
Total: ~$470/month ($0.016 per query)

LLM API (Claude 3.5 Sonnet): $4,200/month
Infrastructure (dedicated): $200/month
Total: ~$4,400/month ($0.015 per query)

LLM API: $0/month (no API calls in demo mode)
Infrastructure: $0/month (no Qdrant/Neo4j needed)
Total: $0/month

from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_answer(question: str):
    result = engine.answer(question)
    return result

# Common questions are cached
result = cached_answer("법인세율은?")  # API call
result = cached_answer("법인세율은?")  # Cached, no API call

from taxia import TaxiaEngine, TaxiaConfig

# Use Haiku for simple questions
simple_config = TaxiaConfig(llm_model="claude-3-haiku-20240307")
simple_engine = TaxiaEngine(config=simple_config)

# Use Sonnet for complex questions
complex_config = TaxiaConfig(llm_model="claude-3-5-sonnet-20241022")
complex_engine = TaxiaEngine(config=complex_config)

def smart_answer(question):
    # Route based on complexity
    if len(question) < 50:  # Simple question
        return simple_engine.answer(question)
    else:  # Complex question
        return complex_engine.answer(question)

# Default: 4000 tokens
config = TaxiaConfig(llm_max_tokens=2000)  # Reduce by 50%
engine = TaxiaEngine(config=config)

# Free for development/testing
test_engine = TaxiaEngine(demo_mode=True)

# Switch to production only when ready
prod_engine = TaxiaEngine(demo_mode=False)

Component Breakdown:
├── Vector Search (Qdrant): 50-200ms
├── LLM Processing (Anthropic): 1,500-3,000ms
├── Citation Extraction: 50-100ms
└── Response Formatting: 10-30ms
─────────────────────────────────────
Total: 1.6-3.3 seconds

Component Breakdown:
├── Vector Search (Qdrant): 50-200ms
├── Graph Query (Neo4j): 100-300ms
├── LLM Processing (Anthropic): 1,500-3,000ms
├── Citation Extraction: 50-100ms
└── Response Formatting: 10-30ms
─────────────────────────────────────
Total: 1.7-3.6 seconds

# Use HNSW index for faster search
config = TaxiaConfig(
    qdrant_hnsw_ef=128,  # Higher = more accurate but slower
    qdrant_hnsw_m=16     # Higher = more memory but faster
)

# Retrieve fewer documents
config = TaxiaConfig(top_k=3)  # Instead of default 5

import asyncio

async def batch_answer(questions):
    tasks = [engine.answer_async(q) for q in questions]
    results = await asyncio.gather(*tasks)
    return results

# Process 10 questions in parallel
questions = ["Q1", "Q2", ..., "Q10"]
results = await batch_answer(questions)

from taxia import TaxiaEngine
import logging

logger = logging.getLogger("taxia.costs")

class CostTracker:
    def __init__(self):
        self.total_queries = 0
        self.total_tokens = 0
        self.total_cost = 0.0

    def log_query(self, result):
        self.total_queries += 1

        # Estimate tokens (actual may vary)
        input_tokens = result.metadata.get("input_tokens", 2000)
        output_tokens = result.metadata.get("output_tokens", 500)

        # Calculate cost (Claude 3.5 Sonnet)
        cost = (input_tokens / 1_000_000 * 3.0) + \
               (output_tokens / 1_000_000 * 15.0)

        self.total_tokens += (input_tokens + output_tokens)
        self.total_cost += cost

        logger.info(f"Query #{self.total_queries}: {cost:.4f} USD")

    def report(self):
        return {
            "total_queries": self.total_queries,
            "total_tokens": self.total_tokens,
            "total_cost": f"${self.total_cost:.2f}",
            "avg_cost_per_query": f"${self.total_cost/self.total_queries:.4f}"
        }

# Usage
tracker = CostTracker()
engine = TaxiaEngine()

result = engine.answer("법인세율은?")
tracker.log_query(result)

# Daily report
print(tracker.report())
# Output: {'total_queries': 145, 'total_cost': '$2.03', 'avg_cost_per_query': '$0.0140'}

class BudgetAlert:
    def __init__(self, daily_budget=50.0):
        self.daily_budget = daily_budget
        self.daily_cost = 0.0

    def check_budget(self, query_cost):
        self.daily_cost += query_cost

        if self.daily_cost >= self.daily_budget:
            raise BudgetExceededError(
                f"Daily budget ${self.daily_budget} exceeded! "
                f"Current: ${self.daily_cost:.2f}"
            )

        if self.daily_cost >= self.daily_budget * 0.8:
            logger.warning(f"80% of daily budget used: ${self.daily_cost:.2f}")

# Usage
budget = BudgetAlert(daily_budget=50.0)
budget.check_budget(0.014)  # Log each query cost

Before TAXIA:
- Support team: 3 people × $3,000/month = $9,000/month
- Handle: 50 queries/day = 1,500/month

After TAXIA:
- Support team: 1 person × $3,000/month = $3,000/month
- TAXIA costs: $470/month
- Handle: 400 queries/day = 12,000/month

Savings: $9,000 - $3,000 - $470 = $5,530/month
ROI: ($5,530 / $470) × 100% = 1,177% ROI
Payback period: < 1 month

Development: 3 engineers × 3 months = $45,000
Maintenance: 1 engineer × 20% = $12,000/year
Infrastructure: $100/month = $1,200/year
Total Year 1: $58,200

Development: 1 engineer × 1 week = $2,500
Monthly costs: $470/month = $5,640/year
Total Year 1: $8,140