Real-World Use Cases

from taxia import TaxiaEngine
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
engine = TaxiaEngine()

class TaxQuestion(BaseModel):
    question: str
    user_id: str

@app.post("/ask")
async def ask_tax_question(query: TaxQuestion):
    result = engine.answer(query.question)

    return {
        "answer": result.answer,
        "legal_citations": [
            {
                "law": c.law_name,
                "article": c.article_number,
                "text": c.text
            } 
            for c in result.citations
        ],
        "confidence": result.confidence,
        "trace_id": result.trace_id
    }

// Simple chat interface
async function askQuestion(question) {
    const response = await fetch('http://api.example.com/ask', {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({
            question: question,
            user_id: getCurrentUserId()
        })
    });

    const data = await response.json();
    displayAnswer(data.answer, data.legal_citations);
}

from slack_bolt import App
from taxia import TaxiaEngine

app = App(token=SLACK_BOT_TOKEN)
engine = TaxiaEngine()

@app.message("세금")  # Triggered by keyword "세금" (tax)
def handle_tax_question(message, say):
    question = message['text']

    # Query TAXIA
    result = engine.answer(question)

    # Format Slack message with citations
    blocks = [
        {
            "type": "section",
            "text": {"type": "mrkdwn", "text": f"*Answer:*\n{result.answer}"}
        },
        {"type": "divider"},
        {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": "*Legal Citations:*\n" + "\n".join([
                    f"• {c.law_name} {c.article_number}: _{c.text[:100]}..._"
                    for c in result.citations[:3]
                ])
            }
        }
    ]

    say(blocks=blocks, thread_ts=message['ts'])

app.start(port=3000)

import streamlit as st
from taxia import TaxiaEngine

# Initialize TAXIA
@st.cache_resource
def get_engine():
    return TaxiaEngine(
        enable_graph_rag=True  # Use graph reasoning for complex queries
    )

engine = get_engine()

# Streamlit UI
st.title("🔍 Tax Research Assistant")
st.caption("Powered by TAXIA - Korean Tax Law Q&A")

# Input
question = st.text_area(
    "Ask a tax law question:",
    placeholder="예: 법인세법 제27조의 접대비 손금불산입 규정은?"
)

if st.button("Search"):
    with st.spinner("Searching tax laws..."):
        result = engine.answer(question)

        # Display answer
        st.success("Answer")
        st.write(result.answer)

        # Display citations
        st.info("Legal Citations")
        for i, citation in enumerate(result.citations, 1):
            with st.expander(f"📄 {citation.law_name} {citation.article_number}"):
                st.write(citation.text)
                st.caption(f"Year: {citation.year}")

        # Display related laws (Graph-RAG)
        if result.related_laws:
            st.warning("Related Laws")
            for law in result.related_laws:
                st.markdown(f"- {law}")

        # Trace ID for debugging
        st.caption(f"Trace ID: {result.trace_id}")

# Compare tax law changes across years
col1, col2 = st.columns(2)

with col1:
    result_2024 = engine.answer(question, year=2024)
    st.write("**2024 Law:**", result_2024.answer)

with col2:
    result_2025 = engine.answer(question, year=2025)
    st.write("**2025 Law:**", result_2025.answer)

# Highlight differences
if result_2024.answer != result_2025.answer:
    st.error("⚠ Law changed between 2024 and 2025!")

from taxia import TaxiaEngine
import asyncio

engine = TaxiaEngine()

async def check_transaction_compliance(transaction):
    """Check if transaction triggers tax obligations"""

    # Build context-aware question
    question = f"""
    거래 내역:
    - 거래 유형: {transaction['type']}
    - 금액: {transaction['amount']:,}원
    - 거래처: {transaction['counterparty']}
    - 업종: {transaction['business_type']}

    이 거래에 대해 원천징수가 필요한가요?
    필요하다면 세율과 근거 법령을 알려주세요.
    """

    result = engine.answer(question)

    # Parse result for automation
    requires_withholding = "원천징수" in result.answer and "필요" in result.answer

    return {
        "transaction_id": transaction['id'],
        "requires_withholding": requires_withholding,
        "explanation": result.answer,
        "legal_basis": [c.article_number for c in result.citations],
        "trace_id": result.trace_id
    }

# Process transactions in batch
async def process_daily_transactions(transactions):
    tasks = [check_transaction_compliance(t) for t in transactions]
    results = await asyncio.gather(*tasks)

    # Flag transactions needing review
    flagged = [r for r in results if r['requires_withholding']]

    return flagged

from taxia import TaxiaEngine
import gradio as gr

engine = TaxiaEngine()

def teaching_assistant(question, difficulty_level):
    """Provide educational tax law answers"""

    # Adjust response based on difficulty
    prompt_prefix = {
        "beginner": "초보자도 이해할 수 있도록 쉽게 설명해주세요: ",
        "intermediate": "세법 기본 지식이 있는 사람을 위해 설명해주세요: ",
        "advanced": "세무 전문가 수준으로 상세히 설명해주세요: "
    }

    full_question = prompt_prefix[difficulty_level] + question
    result = engine.answer(full_question)

    # Format educational response
    response = f"""
### 답변
{result.answer}

### 관련 법령
{chr(10).join([f"- {c.law_name} {c.article_number}" for c in result.citations])}

### 학습 팁
이 내용은 {result.citations[0].law_name}에 명시되어 있습니다.
추가 공부를 위해 관련 조문을 직접 읽어보는 것을 추천합니다.
    """

    return response

# Gradio interface
interface = gr.Interface(
    fn=teaching_assistant,
    inputs=[
        gr.Textbox(label="Tax Law Question", placeholder="예: 법인세율 구간은?"),
        gr.Radio(["beginner", "intermediate", "advanced"], label="난이도")
    ],
    outputs=gr.Markdown(label="Answer"),
    title="🎓 Tax Law Learning Assistant",
    description="Learn Korean tax law interactively with AI-powered Q&A"
)

interface.launch()

# Generate practice questions
scenarios = [
    {
        "scenario": "A company with 300M KRW taxable income",
        "question": "What is the total corporate tax?",
        "learning_goal": "Understanding progressive tax brackets"
    },
    {
        "scenario": "Employee receiving 50M KRW salary",
        "question": "Calculate year-end tax settlement",
        "learning_goal": "Income tax calculation and deductions"
    }
]

for scenario in scenarios:
    st.write(f"**Scenario:** {scenario['scenario']}")
    answer = engine.answer(scenario['question'])
    st.write(f"**Answer:** {answer.answer}")
    st.caption(f"Learning Goal: {scenario['learning_goal']}")

from taxia import TaxiaEngine

# Start with demo mode
engine = TaxiaEngine(demo_mode=True)

# Test with your actual questions
questions = [
    "Your typical question 1",
    "Your typical question 2",
    "Your typical question 3"
]

for q in questions:
    result = engine.answer(q)
    print(f"Q: {q}")
    print(f"A: {result.answer}\n")