Upload 7 files

GenerationEngine.py

@@ -0,0 +1,301 @@
+import streamlit as st
+from langchain_pinecone import PineconeVectorStore
+
+# from langchain_openai import OpenAI, ChatOpenAI
+# from langchain_google_genai import ChatGoogleGenerativeAI
+
+import openai
+
+# from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.output_parsers import PydanticOutputParser
+from dotenv import load_dotenv
+import os
+
+from pydantic import BaseModel, Field
+from typing import List, Union, Tuple, Any
+from typing_extensions import Literal
+
+
+# Function to download Hugging Face embeddings
+def download_hugging_face_embeddings():
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    return embeddings
+
+# Load environment variables
+def load_env_variables():
+    load_dotenv()
+    PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
+    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
+    GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+    os.environ["PINECONE_API_KEY"] = PINECONE_API_KEY
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
+# utils for llm 
+def construct_prompt(prompt: str, role: str):
+   return{
+          "role": role,
+          "content": prompt
+        }
+
+
+# Function to initialize Pinecone vector store and retriever
+def initialize_vector_store(embeddings):
+    index_name = "yolotest"
+    vector_store = PineconeVectorStore.from_existing_index(index_name=index_name, embedding=embeddings)
+    # retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
+    return vector_store
+
+# Pydantic Schemas
+class MetadataSchema(BaseModel):
+    page: float = Field(..., description="Page number of the document")
+    page_label: str = Field(..., description="Page label of the document")
+    total_pages: float = Field(..., description="Total pages in the document")
+    source: str = Field(..., description="Source file path of the document")
+    score: float = Field(..., description="Similarity score of the retrieved document")
+
+class DocumentSchema(BaseModel):
+    metadata: MetadataSchema = Field(..., description="Filtered metadata of the document")
+    page_content: str = Field(..., description="Content of the document page")
+
+class RetrievedDocsSchema(BaseModel):
+    documents: List[DocumentSchema]
+
+
+# Define the individual Question model
+class Question(BaseModel):
+    question: str = Field(..., description="The question prompt that the user needs to answer.")
+    type: Literal['fill_missing', 'MCQ', 'short_answer'] = Field(..., description="The type of question: fill_missing, MCQ, or short_answer.")
+    options: Union[List[str], None] = Field(None, description="The options for the question, used only for MCQ type.")
+
+# Define the Questions model that contains a list of Question objects and the total number of questions
+class Questions(BaseModel):
+    no_of_questions: int = Field(..., description="The total number of questions generated.")
+    questions: List[Question] = Field(..., description="A list of Question objects.")
+
+def initialize_prompts(parser):
+    system_prompt = """
+    You are an AI assistant specializing in question generation. Your role is to analyze the provided query and context to create structured questions that match the given instructions.
+
+    Follow the specified question type format and ensure clarity, correctness, and alignment with the context.
+    """
+
+    document_prompt = """
+    **Query**: {query}
+
+    **Context**: {context}
+
+    **Question Type Instructions:**
+    - If a **specific question type** is provided, generate questions **only in that type**: {question_type}.
+    - Do **not** generate other question types if a type is specified.
+    - If 'MCQ', provide at least **3 options** per question.
+    - If 'fill_missing', leave a **blank space** for the missing word.
+    - If 'short_answer', ensure the **answer is clear** from the context.
+    - If no type is specified (or 'general' is selected), generate a **variety** of question types.
+
+    Ensure that the generated questions align with the query and retrieved context.
+    """
+
+    footer_prompt = f"""
+    **Output Format:**
+    {parser.get_format_instructions()}
+
+    **Important:**
+    - Ensure all questions match the requested type.
+    - Do not generate options unless the type is 'MCQ'.
+    - Maintain high accuracy and relevance to the query and context.
+    """
+
+    return system_prompt, document_prompt, footer_prompt
+
+
+# Initialize components before user query
+embeddings = download_hugging_face_embeddings()
+load_env_variables()
+vector_store = initialize_vector_store(embeddings)
+parser = PydanticOutputParser(pydantic_object=Questions)
+prompt_template = initialize_prompts(parser)
+
+
+# Function for retrieving with score
+def retrieve_and_format_results(vector_store: Any, query: str, k: int = 5, filter: dict = {}) -> RetrievedDocsSchema:
+    """
+    Retrieves documents using similarity search and formats them into the Pydantic schema.
+
+    Args:
+        vector_store (Any): The vector store used for retrieval.
+        query (str): The search query.
+        k (int): Number of documents to retrieve.
+        filter (dict): Optional filter for the search.
+
+    Returns:
+        RetrievedDocsSchema: A structured schema containing documents and metadata.
+    """
+    # Ensure query is valid
+    if not query or not isinstance(query, str):
+        raise ValueError("Query must be a non-empty string.")
+
+    # Retrieve documents with similarity scores
+    try:
+        retrieved_docs = vector_store.similarity_search_with_score(query, k=k, filter=filter)
+    except Exception as e:
+        raise RuntimeError(f"Error retrieving documents: {e}")
+
+    # Convert retrieved documents into the Pydantic schema
+    documents_list = [
+        DocumentSchema(
+            metadata=MetadataSchema(
+                page=doc.metadata.get("page", 0),
+                page_label=doc.metadata.get("page_label", ""),
+                total_pages=doc.metadata.get("total_pages", 0),
+                source=doc.metadata.get("source", ""),
+                score=float(score) if score is not None else 0.0  # Ensure score is a float
+            ),
+            page_content=doc.page_content.strip()  # Trim extra spaces
+        )
+        for doc, score in retrieved_docs if doc.page_content.strip()  # Filter out empty docs
+    ]
+
+    return RetrievedDocsSchema(documents=documents_list)
+
+# LLM to be used
+def generate_text_with_schema(prompt: str, response_format, chat_history: list = None, max_output_tokens: int = None, temperature: float = 0):
+
+    client = openai.OpenAI()
+
+    # Ensure chat_history is initialized and includes the prompt
+    if chat_history is None:
+        chat_history = []
+
+    chat_history.append({"role": "user", "content": prompt})  # Add user message
+
+    response = client.beta.chat.completions.parse(
+        model="gpt-4o-2024-08-06",
+        messages=chat_history,  # Pass the updated history
+        max_tokens=max_output_tokens,
+        temperature=temperature,
+        response_format=response_format
+    )
+
+    return response.choices[0].message.parsed
+
+
+# Process and Generate Questions
+def process_and_generate_questions2(vector_store, query: str, parser, response_format, question_type: str = "general",
+                                   k: int = 5, filter: dict = {}, max_output_tokens: int = None, temperature: float = 0):
+    """
+    Retrieves relevant documents, formats prompts, and generates questions in a structured format.
+
+    Args:
+        vector_store (Any): The vector store used for retrieval.
+        query (str): The search query.
+        parser: Parser object to INST the retriever formatting.
+        response_format: Expected response format for structured output.
+        question_type (str): Type of questions to generate ('MCQ', 'fill_missing', 'short_answer', 'general').
+        k (int): Number of documents to retrieve.
+        filter (dict): Optional filter for retrieval.
+        max_output_tokens (int): Maximum number of tokens in the response.
+        temperature (float): Temperature setting for response generation.
+
+    Returns:
+        Parsed structured response containing generated questions.
+    """
+    retrieved_docs_schema = retrieve_and_format_results(vector_store, query, k, filter)
+    retrieved_docs = retrieved_docs_schema.documents
+    if not retrieved_docs:
+        return {"error": "No relevant documents found for the query."}
+
+    system_prompt, document_prompt_template, footer_prompt = initialize_prompts(parser)
+    # print(f"\n\n sys :{system_prompt} ")
+
+    chat_history = [construct_prompt(prompt=system_prompt, role="system")]
+    # print(f"\n\n hist before :{chat_history} ")
+
+    context = "\n\n".join([doc.page_content for doc in retrieved_docs])
+    # print(f"\n\n context :{context} ")
+
+    try:
+        document_prompt = document_prompt_template.format(query=query, context=context, question_type=question_type)
+    except KeyError as e:
+        raise ValueError(f"Missing format key in document prompt template: {e}")
+    # print(f"\n\n document_prompt :{document_prompt} ")
+    # print(question_type)
+
+
+    full_prompt = f"\n\n{document_prompt}\n\n{footer_prompt}"
+    # print(f"\n\n full_prompt :{full_prompt} ")
+
+    response = generate_text_with_schema(
+        prompt=full_prompt,
+        chat_history = chat_history,
+        response_format=response_format,
+        max_output_tokens=max_output_tokens,
+        temperature=temperature
+    )
+    chat_history.append(construct_prompt(prompt=response, role="assistant"))
+    print(f"\n\n hist after:{chat_history} ")
+
+
+    return response, full_prompt, retrieved_docs_schema, chat_history
+
+
+def main():
+    st.set_page_config(layout="wide")
+    st.title("A Simple RAG App to Generate Questions in Specific Formats")
+
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    col1, col2, col3, col4 = st.columns([1, 2, 2, 2])
+    
+    with col1:
+        st.subheader("Chat History")
+        with st.expander("Show/Hide Chat History", expanded=True):
+            for message in st.session_state.chat_history:
+                st.markdown(f"**{message['role'].capitalize()}**: {message['content']}")
+    
+    with col2:
+        st.subheader("Retrieved Documents")
+        retrieved_docs_schema = RetrievedDocsSchema(documents=[])
+        for doc in retrieved_docs_schema.documents:
+            with st.expander(f"Source: {doc.metadata.source}, Page {doc.metadata.page}/{doc.metadata.total_pages} (Score: {doc.metadata.score:.4f})"):
+                st.text_area("Content:", doc.page_content, height=150)
+    
+    with col3:
+        st.subheader("Generated Prompt")
+        st.write("Final prompt will appear here.")
+    
+    with col4:
+        st.subheader("Generated Response")
+        st.write("Response will be displayed here.")
+
+    question_type = st.selectbox("Select Question Type", ["general", "MCQ", "fill_missing", "short_answer"])
+    query = st.chat_input("Enter your query: ")
+    
+    if query and question_type:
+        with st.spinner('Generating questions...'):
+            st.write(f"**Your query:** {query}")
+            response, full_prompt, retrieved_docs_schema, chat_history = process_and_generate_questions2(
+                vector_store, query, parser, response_format=Questions, question_type=question_type
+            )
+            
+            with col3:
+                st.write(f"**Final prompt is:** {full_prompt}")
+            
+            with col2:
+                for doc in retrieved_docs_schema.documents:
+                    with st.expander(f"Source: {doc.metadata.source}, Page {doc.metadata.page}/{doc.metadata.total_pages} (Score: {doc.metadata.score:.4f})"):
+                        st.text_area("Content:", doc.page_content, height=150)
+            
+            with col1:
+                st.session_state.chat_history.append({"role": "user", "content": query})
+                st.session_state.chat_history.append({"role": "assistant", "content": str(response)})
+                st.markdown(f"**Assistant**: {response}")
+            
+            with col4:
+                st.write(response)
+
+if __name__ == "__main__":
+    main()

app_v1_generation.py

@@ -0,0 +1,73 @@
+import streamlit as st
+
+# from src.helper import download_hugging_face_embeddings
+
+from langchain_pinecone import PineconeVectorStore
+from langchain_openai import OpenAI, ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.chains import create_retrieval_chain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from src.prompt import *
+
+from dotenv import load_dotenv
+import os
+
+
+#Download the Embeddings from Hugging Face
+def download_hugging_face_embeddings():
+    embeddings=HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    return embeddings
+
+
+# Load env Variables
+load_dotenv()
+
+PINECONE_API_KEY=os.environ.get('PINECONE_API_KEY')
+OPENAI_API_KEY=os.environ.get('OPENAI_API_KEY')
+GOOGLE_API_KEY= os.environ.get("GOOGLE_API_KEY")
+
+os.environ["PINECONE_API_KEY"] = PINECONE_API_KEY
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+# Embedding model
+embeddings = download_hugging_face_embeddings()
+
+
+# load exisiting pinecone index
+index_name = "yolotest"
+Vector_store = PineconeVectorStore.from_existing_index(
+    index_name=index_name,
+    embedding=embeddings
+)
+
+# Retriever
+retriever = Vector_store.as_retriever(search_type="similarity", search_kwargs={"k":5})
+
+# llm
+# llm = OpenAI(api_key=OPENAI_API_KEY, temperature=0, max_tokens=500)
+# llm = ChatGoogleGenerativeAI(model="gemini-1.5-pro",temperature=0,max_tokens=None,timeout=None)
+llm = ChatOpenAI(api_key=OPENAI_API_KEY, temperature=0, model='gpt-3.5-turbo-0125')
+
+# streamlit 
+st.title("RAG Application built on Gemini Model")
+query = st.chat_input("Say something: ") 
+prompt = query
+
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", system_prompt),
+        ("human", "{input}"),
+    ]
+)
+
+
+if query:
+    question_answer_chain = create_stuff_documents_chain(llm, prompt)
+    rag_chain = create_retrieval_chain(retriever, question_answer_chain)
+
+    response = rag_chain.invoke({"input": query})
+
+    st.write(response["answer"])

app_v2_generation_schema.py

@@ -0,0 +1,138 @@
+import streamlit as st
+from langchain_pinecone import PineconeVectorStore
+from langchain_openai import OpenAI, ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.output_parsers import PydanticOutputParser
+from dotenv import load_dotenv
+import os
+from pydantic import BaseModel, Field
+from typing import List, Union
+from typing_extensions import Literal
+
+
+# Pydantic Schema
+class Question(BaseModel):
+    question: str = Field(..., description="The question prompt that the user needs to answer.")
+    type: Literal['fill_missing', 'MCQ', 'short_answer'] = Field(..., description="The type of question: fill_missing, MCQ, or short_answer.")
+    options: Union[List[str], None] = Field(None, description="The options for the question, used only for MCQ type.")
+
+class Questions(BaseModel):
+    no_of_questions: int = Field(..., description="The total number of questions generated.")
+    questions: List[Question] = Field(..., description="A list of Question objects.")
+
+
+# Function to download Hugging Face embeddings
+def download_hugging_face_embeddings():
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    return embeddings
+
+
+# Load environment variables
+def load_env_variables():
+    load_dotenv()
+    PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
+    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
+    GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+    os.environ["PINECONE_API_KEY"] = PINECONE_API_KEY
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
+
+# Function to initialize Pinecone vector store and retriever
+def initialize_vector_store(embeddings):
+    index_name = "yolotest"
+    vector_store = PineconeVectorStore.from_existing_index(index_name=index_name, embedding=embeddings)
+    retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
+    return retriever
+
+
+# Function to initialize LLM
+def initialize_llm():
+    llm = ChatOpenAI(api_key=os.environ.get("OPENAI_API_KEY"), temperature=0, model='gpt-3.5-turbo-0125')
+    llm_structured = llm.with_structured_output(Questions)
+    return llm_structured
+
+
+# Function to initialize prompt template
+def initialize_prompt_template(parser):
+    prompt_template = """
+    You are given some context below. Based on the context, generate questions with one of the following types: ['fill_missing', 'MCQ', 'short_answer'].
+
+    Context: {context}
+
+    Make sure to generate a variety of questions. The types should be distributed among 'fill_missing', 'MCQ', and 'short_answer'. 
+
+    For MCQs, provide at least 3 options. For 'fill_missing', make sure to leave a gap that can be filled. For 'short_answer', make sure the answer is clear from the context.
+
+    Return a list of questions, with each question having the following structure:
+    - 'question': The question prompt.
+    - 'type': The type of question: 'fill_missing', 'MCQ', or 'short_answer'.
+    - 'options': For 'MCQ', a list of options. For other types, this field should be omitted.
+
+    The response should be with a format that matches the following structure:
+    {format_instructions}
+    """
+    return prompt_template
+
+
+# Initialize components before user query
+embeddings = download_hugging_face_embeddings()
+load_env_variables()
+retriever = initialize_vector_store(embeddings)
+llm_structured = initialize_llm()
+parser = PydanticOutputParser(pydantic_object=Questions)
+prompt_template = initialize_prompt_template(parser)
+
+
+# Function to generate questions from the context
+def generate_questions_from_context(query: str, retriever, llm_structured, prompt_template, parser):
+    # Retrieve relevant documents from the vector store using the retriever
+    retrieved_docs = retriever.invoke(query)
+    retrieved_docs = [rec.page_content for rec in retrieved_docs]
+
+    # Combine the retrieved documents into a single context string
+    context = " ".join([doc for doc in retrieved_docs])
+
+    # Initialize prompt template
+    prompt = PromptTemplate(template=prompt_template, input_variables=["context"],
+                            partial_variables={"format_instructions": parser.get_format_instructions()})
+
+    # Create chain and generate response
+    chain = prompt | llm_structured
+    response = chain.invoke({
+        "context": context, "format_instructions": parser.get_format_instructions()
+    })
+    return response
+
+
+# Streamlit Interface
+def main():
+    st.title("A Simple RAG App to Generate Questions in Specific Formats")
+
+    # Display user query input
+    query = st.chat_input("Say something: ")
+    if query:
+        with st.spinner('Generating questions...'):
+            st.write(f"Your query: {query}")  # Display user query
+            
+            # Generate questions
+            result = generate_questions_from_context(query, retriever, llm_structured, prompt_template, parser)
+            st.write(result)
+            # # Display the result in a more readable format
+            # st.subheader("Generated Questions")
+            # for i, question in enumerate(result.questions):
+            #     st.markdown(f"### Question {i + 1}: {question.question}")
+            #     st.markdown(f"**Type**: {question.type}")
+            #     if question.type == "MCQ" and question.options:
+            #         st.markdown("**Options**:")
+            #         for option in question.options:
+            #             st.markdown(f"- {option}")
+            #     st.markdown("---")
+
+
+# Run the app
+if __name__ == "__main__":
+    main()

app_v3_schema_history_QTypes.py

@@ -0,0 +1,176 @@
+import streamlit as st
+from langchain_pinecone import PineconeVectorStore
+from langchain_openai import OpenAI, ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.output_parsers import PydanticOutputParser
+from dotenv import load_dotenv
+import os
+from pydantic import BaseModel, Field
+from typing import List, Union
+from typing_extensions import Literal
+
+
+# Pydantic Schema
+class Question(BaseModel):
+    question: str = Field(..., description="The question prompt that the user needs to answer.")
+    type: Literal['fill_missing', 'MCQ', 'short_answer'] = Field(..., description="The type of question: fill_missing, MCQ, or short_answer.")
+    options: Union[List[str], None] = Field(None, description="The options for the question, used only for MCQ type.")
+
+class Questions(BaseModel):
+    no_of_questions: int = Field(..., description="The total number of questions generated.")
+    questions: List[Question] = Field(..., description="A list of Question objects.")
+
+
+# Function to download Hugging Face embeddings
+def download_hugging_face_embeddings():
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    return embeddings
+
+
+# Load environment variables
+def load_env_variables():
+    load_dotenv()
+    PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
+    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
+    GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+    os.environ["PINECONE_API_KEY"] = PINECONE_API_KEY
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
+
+# Function to initialize Pinecone vector store and retriever
+def initialize_vector_store(embeddings):
+    index_name = "yolotest"
+    vector_store = PineconeVectorStore.from_existing_index(index_name=index_name, embedding=embeddings)
+    retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
+    return retriever
+
+
+# Function to initialize LLM
+def initialize_llm():
+    llm = ChatOpenAI(api_key=os.environ.get("OPENAI_API_KEY"), temperature=0, model='gpt-3.5-turbo-0125')
+    llm_structured = llm.with_structured_output(Questions)
+    return llm_structured
+
+
+# Function to initialize prompt template
+def initialize_prompt_template(parser):
+    prompt_template = """
+    You are given some context below. Based on the context, generate questions.
+    
+    Context: {context}
+    
+    - If a question type is specified, generate questions **only in that type**: {question_type}.
+    - If 'MCQ', provide at least 3 options per question.
+    - If 'fill_missing', leave a blank space for the missing word.
+    - If 'short_answer', ensure the answer is clear from the context.
+    - If no type is specified (or 'general' is selected), generate a variety of question types.
+
+    **Ensure that the generated questions match the requested type.**
+    
+    The response should follow this structure:
+    
+    - 'question': The question prompt.
+    - 'type': The type of question (should match the requested type, unless 'general').
+    - 'options': For 'MCQ', a list of answer options (otherwise, omit this field).
+    
+    The response should strictly match this format:
+    {format_instructions}
+    """
+    return prompt_template
+
+
+
+
+# Initialize components before user query
+embeddings = download_hugging_face_embeddings()
+load_env_variables()
+retriever = initialize_vector_store(embeddings)
+llm_structured = initialize_llm()
+parser = PydanticOutputParser(pydantic_object=Questions)
+prompt_template = initialize_prompt_template(parser)
+
+# Function to generate questions from the context
+def generate_questions_from_context(query: str, retriever, llm_structured, prompt_template, parser, chat_history, question_type=None):
+    # Default to 'general' if no question type is specified
+    if question_type is None:
+        question_type = "general"
+
+    # Append user query to chat history
+    chat_history.append({"role": "user", "content": query})
+
+    # # If history is too long, summarize it
+    # if len(chat_history) > 5:
+    #     chat_history = summarize_chat_history(chat_history, llm_structured)
+
+    # Retrieve relevant documents from the vector store using the retriever
+    retrieved_docs = retriever.invoke(query)
+    retrieved_docs = [rec.page_content for rec in retrieved_docs]
+
+    # Combine retrieved documents into a single context string
+    context = " ".join([doc for doc in retrieved_docs] + [entry['content'] for entry in chat_history])
+
+    # Initialize prompt template with the user-specified or default question type
+    prompt = PromptTemplate(
+        template=prompt_template,
+        input_variables=["context", "question_type"],
+        partial_variables={"format_instructions": parser.get_format_instructions()}
+    )
+
+    # Create chain and generate response
+    chain = prompt | llm_structured
+    response = chain.invoke({
+        "context": context,
+        "question_type": question_type,
+        "format_instructions": parser.get_format_instructions()
+    })
+
+    # Append model response to chat history
+    chat_history.append({"role": "assistant", "content": str(response)})
+
+    return response
+
+
+
+
+# Streamlit Interface
+def main():
+    st.title("A Simple RAG App to Generate Questions in Specific Formats")
+
+    # Initialize chat history in session state
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    # Sidebar for chat history
+    with st.sidebar:
+        st.subheader("Chat History")
+        with st.expander("Show/Hide Chat History", expanded=False):
+            for message in st.session_state.chat_history:
+                if message['role'] == 'user':
+                    st.markdown(f"**User**: {message['content']}")
+                else:
+                    st.markdown(f"**Assistant**: {message['content']}")
+
+    # Add a dropdown in Streamlit to let the user choose the question type, defaulting to 'general'
+    question_type = st.selectbox("Select Question Type", ["general", "MCQ", "fill_missing", "short_answer"])
+
+    # Get user input
+    query = st.chat_input("Say something: ")
+
+    if query:
+        with st.spinner('Generating questions...'):
+            st.write(f"Your query: {query}")  # Display user query
+
+            result = generate_questions_from_context(
+                query, retriever, llm_structured, prompt_template, parser, st.session_state.chat_history, question_type
+            )
+            st.write(result)
+
+
+
+# Run the app
+if __name__ == "__main__":
+    main()

app_v4.py

@@ -0,0 +1,192 @@
+import streamlit as st
+from langchain_pinecone import PineconeVectorStore
+from langchain_openai import OpenAI, ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.output_parsers import PydanticOutputParser
+from dotenv import load_dotenv
+import os
+from pydantic import BaseModel, Field
+from typing import List, Union
+from typing_extensions import Literal
+
+
+# Pydantic Schema
+
+# Generation Schema
+class Question(BaseModel):
+    question: str = Field(..., description="The question prompt that the user needs to answer.")
+    type: Literal['fill_missing', 'MCQ', 'short_answer'] = Field(..., description="The type of question: fill_missing, MCQ, or short_answer.")
+    options: Union[List[str], None] = Field(None, description="The options for the question, used only for MCQ type.")
+
+class Questions(BaseModel):
+    no_of_questions: int = Field(..., description="The total number of questions generated.")
+    questions: List[Question] = Field(..., description="A list of Question objects.")
+
+# Retrieval schema
+class MetadataSchema(BaseModel):
+    page: float = Field(..., description="Page number of the document")
+    page_label: str = Field(..., description="Page label of the document")
+    total_pages: float = Field(..., description="Total pages in the document")
+    source: str = Field(..., description="Source file path of the document")
+
+class DocumentSchema(BaseModel):
+    metadata: MetadataSchema = Field(..., description="Filtered metadata of the document")
+    page_content: str = Field(..., description="Content of the document page")
+
+class RetrievedDocsSchema(BaseModel):
+    documents: List[DocumentSchema]
+
+
+# Function to download Hugging Face embeddings
+def download_hugging_face_embeddings():
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    return embeddings
+
+
+# Load environment variables
+def load_env_variables():
+    load_dotenv()
+    PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
+    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
+    GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+    os.environ["PINECONE_API_KEY"] = PINECONE_API_KEY
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
+
+# Function to initialize Pinecone vector store and retriever
+def initialize_vector_store(embeddings):
+    index_name = "yolotest"
+    vector_store = PineconeVectorStore.from_existing_index(index_name=index_name, embedding=embeddings)
+    retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
+    return retriever
+
+
+# Function to initialize LLM
+def initialize_llm():
+    llm = ChatOpenAI(api_key=os.environ.get("OPENAI_API_KEY"), temperature=0, model='gpt-3.5-turbo-0125')
+    llm_structured = llm.with_structured_output(Questions)
+    return llm_structured
+
+
+# Function to initialize prompt template
+def initialize_prompt_template(parser):
+    prompt_template = """
+    You are given some context below. Based on the context, generate questions.
+    
+    Context: {context}
+    
+    - If a question type is specified, generate questions **only in that type**: {question_type}.
+    - If a question type is specified, Do not generate any other question type expect for the type mentioned
+    - If 'MCQ', provide at least 3 options per question.
+    - If 'fill_missing', leave a blank space for the missing word.
+    - If 'short_answer', ensure the answer is clear from the context.
+    - If no type is specified (or 'general' is selected), generate a variety of question types.
+
+    **Ensure that the generated questions match the requested type.**
+    
+    The response should follow this structure:
+    
+    - 'question': The question prompt.
+    - 'type': The type of question (should match the requested type, unless 'general').
+    - 'options': For 'MCQ', a list of answer options (otherwise, omit this field).
+    
+    The response should strictly match this format:
+    {format_instructions}
+    """
+    return prompt_template
+
+
+# Initialize components before user query
+embeddings = download_hugging_face_embeddings()
+load_env_variables()
+retriever = initialize_vector_store(embeddings)
+llm_structured = initialize_llm()
+parser = PydanticOutputParser(pydantic_object=Questions)
+prompt_template = initialize_prompt_template(parser)
+
+
+def retrieve_documents(retriever, query: str, k: int = 5) -> RetrievedDocsSchema:
+    retrieved_docs = retriever.invoke(query)
+    
+    extracted_docs = [
+        DocumentSchema(
+            metadata=MetadataSchema(
+                page=doc.metadata.get("page", 0.0),
+                page_label=doc.metadata.get("page_label", ""),
+                total_pages=doc.metadata.get("total_pages", 0.0),
+                source=doc.metadata.get("source", "")
+            ),
+            page_content=doc.page_content
+        )
+        for doc in retrieved_docs
+    ]
+    
+    return RetrievedDocsSchema(documents=extracted_docs)
+
+
+def generate_questions_from_context(query: str, retriever, llm_structured, prompt_template, parser, chat_history, question_type=None):
+    if question_type is None:
+        question_type = "general"
+
+    chat_history.append({"role": "user", "content": query})
+    retrieved_docs_schema = retrieve_documents(retriever, query)
+    retrieved_docs = [doc.page_content for doc in retrieved_docs_schema.documents]
+    context = " ".join(retrieved_docs)
+    
+    prompt = PromptTemplate(
+        template=prompt_template,
+        input_variables=["context", "question_type"],
+        partial_variables={"format_instructions": parser.get_format_instructions()}
+    )
+    
+    chain = prompt | llm_structured
+    response = chain.invoke({
+        "context": context,
+        "question_type": question_type,
+        "format_instructions": parser.get_format_instructions()
+    })
+    
+    chat_history.append({"role": "assistant", "content": str(response)})
+    return response, retrieved_docs_schema
+
+# Streamlit interface
+def main():
+    st.title("A Simple RAG App to Generate Questions in Specific Formats")
+
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    with st.sidebar:
+        st.subheader("Chat History")
+        with st.expander("Show/Hide Chat History", expanded=False):
+            for message in st.session_state.chat_history:
+                st.markdown(f"**{message['role'].capitalize()}**: {message['content']}")
+
+    question_type = st.selectbox("Select Question Type", ["general", "MCQ", "fill_missing", "short_answer"])
+    query = st.chat_input("Enter your query: ")
+
+    if query and question_type:
+        with st.spinner('Generating questions...'):
+            st.write(f"**Your query:** {query}")
+            response, retrieved_docs_schema = generate_questions_from_context(
+                query, retriever, llm_structured, prompt_template, parser, st.session_state.chat_history, question_type
+            )
+            
+            st.subheader("Generated Questions")
+            st.write(response)
+            # st.write(question_type)
+            st.subheader("Retrieved Documents")
+            for doc in retrieved_docs_schema.documents:
+                st.markdown(f"**Source:** {doc.metadata.source}, Page {doc.metadata.page}/{doc.metadata.total_pages}")
+                st.text_area("Content:", doc.page_content, height=100)
+
+            # st.subheader("Chat History")
+            # for message in st.session_state.chat_history:
+            #     st.markdown(f"**{message['role'].capitalize()}**: {message['content']}")
+
+if __name__ == "__main__":
+    main()

app_v5_scoring.py

@@ -0,0 +1,260 @@
+import streamlit as st
+from langchain_pinecone import PineconeVectorStore
+from langchain_openai import OpenAI, ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.output_parsers import PydanticOutputParser
+from dotenv import load_dotenv
+import os
+from pydantic import BaseModel, Field
+from typing import List, Union, Tuple, Any
+from typing_extensions import Literal
+
+
+# Pydantic Schema
+
+# Generation Schema
+class Question(BaseModel):
+    question: str = Field(..., description="The question prompt that the user needs to answer.")
+    type: Literal['fill_missing', 'MCQ', 'short_answer'] = Field(..., description="The type of question: fill_missing, MCQ, or short_answer.")
+    options: Union[List[str], None] = Field(None, description="The options for the question, used only for MCQ type.")
+
+class Questions(BaseModel):
+    no_of_questions: int = Field(..., description="The total number of questions generated.")
+    questions: List[Question] = Field(..., description="A list of Question objects.")
+
+# Retrieval schema
+class MetadataSchema(BaseModel):
+    page: float = Field(..., description="Page number of the document")
+    page_label: str = Field(..., description="Page label of the document")
+    total_pages: float = Field(..., description="Total pages in the document")
+    source: str = Field(..., description="Source file path of the document")
+    score: float = Field(..., description="Similarity score of the retrieved document")
+
+class DocumentSchema(BaseModel):
+    metadata: MetadataSchema = Field(..., description="Filtered metadata of the document")
+    page_content: str = Field(..., description="Content of the document page")
+
+class RetrievedDocsSchema(BaseModel):
+    documents: List[DocumentSchema]
+
+
+# Function to download Hugging Face embeddings
+def download_hugging_face_embeddings():
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+    return embeddings
+
+
+# Load environment variables
+def load_env_variables():
+    load_dotenv()
+    PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
+    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
+    GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+    os.environ["PINECONE_API_KEY"] = PINECONE_API_KEY
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
+
+# Function to initialize Pinecone vector store and retriever
+def initialize_vector_store(embeddings):
+    index_name = "yolotest"
+    vector_store = PineconeVectorStore.from_existing_index(index_name=index_name, embedding=embeddings)
+    # retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
+    return vector_store
+
+
+# Function to initialize LLM
+def initialize_llm():
+    llm = ChatOpenAI(api_key=os.environ.get("OPENAI_API_KEY"), temperature=0, model='gpt-3.5-turbo-0125')
+    llm_structured = llm.with_structured_output(Questions)
+    return llm_structured
+
+
+# Function to initialize prompt template
+# Function to initialize prompt template
+def initialize_prompt_template(parser):
+    prompt_template = """
+    You are given a **query** and relevant **context** below. Based on both, generate questions.
+
+    **Query**: {query}
+
+    **Context**: {context}
+
+    **Question Type Instructions:**
+    - If a **specific question type** is provided, generate questions **only in that type**: {question_type}.
+    - Do **not** generate other question types if a type is specified.
+    - If 'MCQ', provide at least **3 options** per question.
+    - If 'fill_missing', leave a **blank space** for the missing word.
+    - If 'short_answer', ensure the **answer is clear** from the context.
+    - If no type is specified (or 'general' is selected), generate a **variety** of question types.
+
+    **Ensure the generated questions align with the query and the retrieved context.**
+
+    The response should be structured in this format:
+    
+    - 'question': The question prompt.
+    - 'type': The type of question (should match the requested type, unless 'general').
+    - 'options': For 'MCQ', a list of answer options (omit for other types).
+
+    **Strictly follow this structured format**:
+    {format_instructions}
+    """
+    return prompt_template
+
+
+
+# Initialize components before user query
+embeddings = download_hugging_face_embeddings()
+load_env_variables()
+vector_store = initialize_vector_store(embeddings)
+llm_structured = initialize_llm()
+parser = PydanticOutputParser(pydantic_object=Questions)
+prompt_template = initialize_prompt_template(parser)
+
+# Function for retrieving with score
+def retrieve_and_format_results(vector_store: Any, query: str, k: int = 5, filter: dict = {}) -> RetrievedDocsSchema:
+    """
+    Retrieves documents using similarity search and formats them into the Pydantic schema.
+
+    Args:
+        vector_store (Any): The vector store used for retrieval.
+        query (str): The search query.
+        k (int): Number of documents to retrieve.
+        filter (dict): Optional filter for the search.
+
+    Returns:
+        RetrievedDocsSchema: A structured schema containing documents and metadata.
+    """
+    # Retrieve documents with similarity scores
+    retrieved_docs = vector_store.similarity_search_with_score(query, k=k, filter=filter)
+
+    # Convert retrieved documents into the Pydantic schema
+    documents_list = [
+        DocumentSchema(
+            metadata=MetadataSchema(
+                page=doc.metadata.get("page", 0),
+                page_label=doc.metadata.get("page_label", ""),
+                total_pages=doc.metadata.get("total_pages", 0),
+                source=doc.metadata.get("source", ""),
+                score=score  # Assign the similarity score
+            ),
+            page_content=doc.page_content
+        )
+        for doc, score in retrieved_docs
+    ]
+
+    return RetrievedDocsSchema(documents=documents_list)
+
+# llm Generation function
+def generate_questions_from_context(query: str, vector_store: Any, llm_structured, prompt_template: str,
+    parser: PydanticOutputParser, chat_history: List[dict], question_type: str = "general") -> Tuple[Any, RetrievedDocsSchema]:
+    """
+    Generates questions based on retrieved document context using an LLM.
+
+    Args:
+        query (str): The search query.
+        vector_store (Any): The vector store used for retrieval.
+        llm_structured: The structured LLM output function.
+        prompt_template (str): The prompt template for question generation.
+        parser (PydanticOutputParser): The Pydantic output parser.
+        chat_history (List[dict]): A list to store conversation history.
+        question_type (str): The type of question (default is "general").
+
+    Returns:
+        Tuple[Any, RetrievedDocsSchema]: A tuple containing the LLM-generated response and retrieved document schema.
+    """
+    # Append user query to chat history
+    chat_history.append({"role": "user", "content": query})
+
+    # Retrieve and format results using structured schema
+    retrieved_docs_schema = retrieve_and_format_results(vector_store, query, k=5, filter={})
+
+    # Extract only the page_content from the retrieved documents
+    retrieved_docs = [doc.page_content for doc in retrieved_docs_schema.documents]
+
+    # Combine retrieved documents into a single context string
+    context = " ".join(retrieved_docs)
+
+    # Initialize the prompt with query, context, and format instructions
+    prompt = PromptTemplate(
+        template=prompt_template,
+        input_variables=["query", "context", "question_type"],
+        partial_variables={"format_instructions": parser.get_format_instructions()}
+    )
+
+    # Format the prompt with input variables
+    formatted_prompt = prompt.format(
+        query=query,
+        context=context,
+        question_type=question_type
+    )
+
+    # Generate response using the LLM
+    chain = prompt | llm_structured
+    response = chain.invoke({
+        "query": query,
+        "context": context,
+        "question_type": question_type,
+        "format_instructions": parser.get_format_instructions()
+    })
+
+
+    # Append assistant response to chat history
+    chat_history.append({"role": "assistant", "content": str(response)})
+
+    return response, retrieved_docs_schema, formatted_prompt
+
+
+# Streamlit interface
+import streamlit as st
+
+def main():
+    st.title("A Simple RAG App to Generate Questions in Specific Formats")
+
+    # Initialize chat history in session state
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    # Sidebar for Chat History
+    with st.sidebar:
+        st.subheader("Chat History")
+        with st.expander("Show/Hide Chat History", expanded=False):
+            for message in st.session_state.chat_history:
+                st.markdown(f"**{message['role'].capitalize()}**: {message['content']}")
+
+    # Dropdown for Question Type Selection
+    question_type = st.selectbox("Select Question Type", ["general", "MCQ", "fill_missing", "short_answer"])
+
+    # Input for Query
+    query = st.chat_input("Enter your query: ")
+
+    if query and question_type:
+        with st.spinner('Generating questions...'):
+            st.write(f"**Your query:** {query}")
+
+            # Call the updated function that now returns the generated prompt as well
+            response, retrieved_docs_schema, generated_prompt = generate_questions_from_context(
+                query, vector_store, llm_structured, prompt_template, parser, st.session_state.chat_history, question_type
+            )
+
+            # Display Generated Prompt
+            st.subheader("Generated Prompt")
+            # st.code(generated_prompt, language="plaintext")
+            st.write(f"**Final prompt is:** {generated_prompt}")
+
+            # Display Generated Questions
+            st.subheader("Generated Questions")
+            st.write(response)  # Displaying as structured JSON for clarity
+
+            # Display Retrieved Documents with Scores
+            st.subheader("Retrieved Documents")
+            for doc in retrieved_docs_schema.documents:
+                with st.expander(f"Source: {doc.metadata.source}, Page {doc.metadata.page}/{doc.metadata.total_pages} (Score: {doc.metadata.score:.4f})"):
+                    st.text_area("Content:", doc.page_content, height=150)
+
+if __name__ == "__main__":
+    main()
+