from fastapi import FastAPI
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

app = FastAPI()

# Initialize RAG pipeline
embeddings = OpenAIEmbeddings()
vectorstore = Pinecone.from_existing_index(
    "company-docs", embeddings
)

@app.post("/query")
async def query_documents(question: str):
    """RAG-powered document query endpoint"""
    qa_chain = RetrievalQA.from_chain_type(
        llm=OpenAI(model="GPT-5", temperature=0),
        chain_type="stuff",
        retriever=vectorstore.as_retriever(
            search_kwargs={"k": 3}
        ),
        return_source_documents=True
    )

    result = qa_chain({"query": question})
    return {
        "answer": result["result"],
        "sources": [doc.metadata["source"]
                   for doc in result["source_documents"]],
        "confidence": 0.95
    }
  

from fastapi import FastAPI, Depends
from redis import Redis
from typing import List
import asyncio

app = FastAPI()

# Microservice with caching layer
redis = Redis(host='redis', port=6379, decode_responses=True)

@app.post("/api/v1/products")
async def get_products(
    category: str,
    cache: Redis = Depends(lambda: redis)
):
    """Scalable product API with Redis caching"""

    # Check cache first
    cache_key = f"products:{category}"
    cached = await cache.get(cache_key)

    if cached:
        return {"data": cached, "source": "cache"}

    # Query database if not cached
    products = await query_products_from_db(category)

    # Cache for 5 minutes
    await cache.setex(
        cache_key,
        300,
        products.json()
    )

    return {"data": products, "source": "database"}

async def query_products_from_db(category: str):
    """Database query with connection pooling"""
    async with get_db_pool().acquire() as conn:
        return await conn.fetch(
            "SELECT * FROM products WHERE category = $1",
            category
        )