from fastapi import FastAPI, HTTPException
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from pydantic import BaseModel

app = FastAPI()

class QueryRequest(BaseModel):
    question: str
    top_k: int = 3

@app.post("/query")
async def query_documents(request: QueryRequest):
    """RAG-powered document query endpoint"""

    # Initialize embeddings and vector store
    embeddings = OpenAIEmbeddings(openai_api_key=os.getenv("OPENAI_API_KEY"))
    vectorstore = Pinecone.from_existing_index(
        index_name="documents",
        embedding=embeddings
    )

    # Create RAG chain
    qa_chain = RetrievalQA.from_chain_type(
        llm=OpenAI(model="GPT-5", temperature=0),
        chain_type="stuff",
        retriever=vectorstore.as_retriever(
            search_kwargs={"k": request.top_k}
        ),
        return_source_documents=True
    )

    # Execute query
    result = qa_chain({"query": request.question})

    return {
        "answer": result["result"],
        "sources": [
            doc.metadata.get("source", "unknown")
            for doc in result["source_documents"]
        ],
        "confidence": 0.95
    }
                 

import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';

const JWT_SECRET = process.env.JWT_SECRET;
const JWT_EXPIRES_IN = '7d';
const SALT_ROUNDS = 10;

interface User {
  id: string;
  email: string;
  password: string;
}

async function hashPassword(
  password: string
): Promise<string> {
  const salt = await bcrypt.genSalt(SALT_ROUNDS);
  return bcrypt.hash(password, salt);
}

async function createUser(
  email: string,
  password: string
): Promise<{ user: User; token: string }> {
  // Check if user exists
  const existingUser = await getUserByEmail(email);
  if (existingUser) {
    throw new Error('User already exists');
  }

  // Hash password
  const hashedPassword = await hashPassword(password);

  // Create user
  const user = await saveUser({
    id: generateId(),
    email,
    password: hashedPassword
  });

  // Generate JWT token
  const token = jwt.sign(
    { id: user.id, email: user.email },
    JWT_SECRET,
    { expiresIn: JWT_EXPIRES_IN }
  );

  return { user, token };
}

// Usage in API route
export async function POST(request: Request) {
  const { email, password } = await request.json();
  const { user, token } = await createUser(email, password);

  return Response.json({
    success: true,
    message: 'Account created successfully',
    token,
    user: { id: user.id, email: user.email }
  });
}