Update app.py

app.py

@@ -1,217 +1,40 @@
-import gradio as gr
-import pandas as pd
-import pickle
-import streamlit as st
-from llama_index.core import StorageContext, load_index_from_storage, VectorStoreIndex, SimpleDirectoryReader, ChatPromptTemplate
-from llama_index.llms.huggingface import HuggingFaceInferenceAPI
-from dotenv import load_dotenv
-from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-import os
-import base64
+from fastapi import FastAPI
+from llama_index_llms_huggingface_api import HuggingFaceInferenceAPI
+from pydantic import BaseModel
 
-# Load environment variables
-load_dotenv()
+# Define your Pydantic model with protected namespaces disabled
+class ModelConfig(BaseModel):
+    model_id: str
+    model_name: str
 
-# Configure the Llama index settings
-Settings.llm = HuggingFaceInferenceAPI(
-    model_name="google/gemma-1.1-7b-it",
-    tokenizer_name="google/gemma-1.1-7b-it",
-    context_window=3000,
-    token=os.getenv("HF_TOKEN"),
-    max_new_tokens=512,
-    generate_kwargs={"temperature": 0.1},
-)
-Settings.embed_model = HuggingFaceEmbedding(
-    model_name="BAAI/bge-small-en-v1.5"
-)
-
-# Define the directory for persistent storage and data
-PERSIST_DIR = "./db"
-DATA_DIR = "data"
-
-# Ensure data directory exists
-os.makedirs(DATA_DIR, exist_ok=True)
-os.makedirs(PERSIST_DIR, exist_ok=True)
-
-def displayPDF(file):
-    with open(file, "rb") as f:
-        base64_pdf = base64.b64encode(f.read()).decode('utf-8')
-    pdf_display = f'<iframe src="data:application/pdf;base64,{base64_pdf}" width="100%" height="600" type="application/pdf"></iframe>'
-    st.markdown(pdf_display, unsafe_allow_html=True)
-
-def data_ingestion():
-    documents = SimpleDirectoryReader(DATA_DIR).load_data()
-    storage_context = StorageContext.from_defaults()
-    index = VectorStoreIndex.from_documents(documents)
-    index.storage_context.persist(persist_dir=PERSIST_DIR)
-
-def handle_query(query):
-    storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
-    index = load_index_from_storage(storage_context)
-    chat_text_qa_msgs = [
-    (
-        "user",
-        """You are a Q&A assistant named AskAI, created by Vatsa. You have a specific response programmed for when users specifically ask about your creator, Suriya. The response is: "I was created by Suriya, an enthusiast in Artificial Intelligence. He is dedicated to solving complex problems and delivering innovative solutions. With a strong focus on machine learning, deep learning, Python, generative AI, NLP, and computer vision, Suriya is passionate about pushing the boundaries of AI to explore new possibilities." For all other inquiries, your main goal is to provide answers as accurately as possible, based on the instructions and context you have been given. If a question does not match the provided context or is outside the scope of the document, kindly advise the user to ask questions within the context of the document.
-        Context:
-        {context_str}
-        Question:
-        {query_str}
-        """
-    )
-    ]
-    text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
-    
-    query_engine = index.as_query_engine(text_qa_template=text_qa_template)
-    answer = query_engine.query(query)
-    
-    if hasattr(answer, 'response'):
-        return answer.response
-    elif isinstance(answer, dict) and 'response' in answer:
-        return answer['response']
-    else:
-        return "Sorry, I couldn't find an answer."
-
-# Gradio part - Machine Health Prediction
-def predict_status(air_temp, proc_temp, speed, torque, tool_wear):
-    # Load the saved model and feature columns
-    with open('logistic_regression_model.pkl', 'rb') as model_file:
-        model = pickle.load(model_file)
-
-    with open('feature_columns.pkl', 'rb') as col_file:
-        feature_columns = pickle.load(col_file)
-
-    # Prepare the input data
-    sample_input = {
-        "Air temperature [K]": air_temp,
-        "Process temperature [K]": proc_temp,
-        "Rotational speed [rpm]": speed,
-        "Torque [Nm]": torque,
-        "Tool wear [min]": tool_wear
-    }
-
-    # Convert the sample input to a DataFrame
-    sample_df = pd.DataFrame([sample_input])
-
-    # Ensure all columns from training data are present in the sample DataFrame
-    for col in feature_columns:
-        if col not in sample_df.columns:
-            sample_df[col] = 0  # Add missing columns and fill with 0
-
-    # Reorder columns to match the order in the training data
-    sample_df = sample_df[feature_columns]
-
-    # Make a prediction
-    prediction = model.predict(sample_df)[0]
-
-    # Initialize the reason list
-    reasons = []
+    class Config:
+        protected_namespaces = ()  # Disable protected namespaces warning
 
-    # Define acceptable ranges for each feature with user-friendly feedback
-    acceptable_ranges = {
-        "Air temperature [K]": (150, 500),
-        "Process temperature [K]": (150, 500),
-        "Rotational speed [rpm]": (500, 1500),
-        "Torque [Nm]": (100, 800),
-        "Tool wear [min]": (50, 300)
-    }
+# Define Settings class
+class Settings:
+    llm = None  # Initialize the llm attribute
 
-    # User-friendly reasons for each feature
-    if air_temp < 150:
-        reasons.append("• The air temperature is too low, which might be causing the machine to underperform.")
-    elif air_temp > 500:
-        reasons.append("• The air temperature is too high, which could be causing the machine to overheat.")
+# Initialize FastAPI app
+app = FastAPI()
 
-    if proc_temp < 150:
-        reasons.append("• The process temperature is below the normal range, possibly affecting machine efficiency.")
-    elif proc_temp > 500:
-        reasons.append("• The process temperature is too high, which might lead to overheating.")
-
-    if speed < 500:
-        reasons.append("• The rotational speed is too low, causing the machine to operate inefficiently.")
-    elif speed > 1500:
-        reasons.append("• The rotational speed is too high, which might be causing excessive strain on the machine.")
-
-    if torque < 100:
-        reasons.append("• The torque is too low, which may indicate that the machine is not operating at its full capacity.")
-    elif torque > 800:
-        reasons.append("• The torque is too high, possibly putting excessive stress on the machine's components.")
-
-    if tool_wear < 50:
-        reasons.append("• The tool wear is minimal, but routine checks are still recommended to prevent future issues.")
-    elif tool_wear > 300:
-        reasons.append("• The tool wear is high, and the tool may need to be replaced soon to maintain optimal performance.")
-
-    # Generate the final result message
-    if prediction == 0:
-        result_message = "🔴 Machine is NOT working.\n"  # First line for machine status
-        if reasons:
-            result_message += "\n".join(reasons)  # Second row onward for reasons with bullet points
-        else:
-            result_message += "No specific reason identified."  # In case no issues found
-    else:
-        result_message = "🟢 Machine is working fine."
-
-    return result_message
-
-# Gradio interface setup
-def create_gradio_app():
-    iface = gr.Interface(
-        fn=predict_status,
-        inputs=[
-            gr.Slider(label="Air Temperature (K)", minimum=0, maximum=1000, step=0.01, value=300),
-            gr.Slider(label="Process Temperature (K)", minimum=0, maximum=1000, step=0.01, value=300),
-            gr.Slider(label="Rotational Speed (rpm)", minimum=0, maximum=2000, step=1, value=1000),
-            gr.Slider(label="Torque (Nm)", minimum=0, maximum=1000, step=0.1, value=500),
-            gr.Slider(label="Tool Wear (min)", minimum=0, maximum=1000, step=1, value=100),
-        ],
-        outputs="text",
-        title="Smart Machine Health Predictor",
-        description="Provide machine parameters to predict whether the machine is working or not."
-    )
-    return iface
-
-# Streamlit app layout
-st.title("Integrated Machine Health & PDF Q&A")
-
-tab1, tab2 = st.tabs(["Machine Health Prediction", "PDF Chatbot"])
-
-with tab1:
-    st.markdown("### Machine Health Prediction (Gradio App)")
-    # Embed Gradio app into Streamlit using iframe
-    gradio_app = create_gradio_app()
-    gradio_app.launch(share=True)  # We need to launch Gradio in an iframe.
-
-with tab2:
-    st.markdown("### PDF Chatbot by Vatsa Solution Pvt Ltd")
-    st.markdown("Upload a PDF and ask questions related to its content.")
-
-    if 'messages' not in st.session_state:
-        st.session_state.messages = [{'role': 'assistant', "content": 'Hello! Upload a PDF and ask me anything about its content.'}]
-
-    with st.sidebar:
-        st.title("Menu:")
-        uploaded_file = st.file_uploader("Upload your PDF Files and Click on the Submit & Process Button")
-        if st.button("Submit & Process"):
-            with st.spinner("Processing..."):
-                filepath = "data/saved_pdf.pdf"
-                with open(filepath, "wb") as f:
-                    f.write(uploaded_file.getvalue())
-                displayPDF(filepath)
-                data_ingestion()
-                st.success("Data processed and saved to the database!")
-
-    st.markdown("#### Chat Interface:")
-    # Chat interface
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
+# Set up the HuggingFaceInferenceAPI with the new class
+Settings.llm = HuggingFaceInferenceAPI(
+    api_key="your_api_key",  # Replace with your actual API key
+    model_name="your_model_name"  # Replace with your actual model name
+)
 
-    if prompt := st.chat_input():
-        st.session_state.messages.append({"role": "user", "content": prompt})
-        with st.chat_message("user"):
-            st.markdown(prompt)
-        with st.chat_message("assistant"):
-            with st.spinner("Thinking..."):
-                response = handle_query(prompt)
-                st.session_state.messages.append({"role": "assistant", "content": response})
-                st.markdown(response)
+# Sample endpoint to test the LLM
+@app.post("/predict/")
+async def predict(input_text: str):
+    try:
+        response = Settings.llm.generate(input_text)  # Replace with the appropriate method for your API
+        return {"prediction": response}
+    except Exception as e:
+        return {"error": str(e)}
+
+# Sample endpoint to retrieve model configuration
+@app.get("/model-config/")
+async def get_model_config():
+    return {"model_id": Settings.llm.model_id, "model_name": Settings.llm.model_name}
+
+# Run the app using: uvicorn app:app --reload