Spaces:

iscg34
/

finalproject

Sleeping

@@ -1,157 +0,0 @@
-# gradio_ai_chatbot_dotenv.py
-#
-# To run this script:
-# 1. Create a .env file in the same directory with your OPENAI_API_KEY.
-#    Example .env file content:
-#    OPENAI_API_KEY="sk-yourActualOpenAIapiKeyGoesHere"
-# 2. Install the required packages:
-#    pip install gradio langchain openai langchain_openai python-dotenv
-# 3. Run the script from your terminal:
-#    python gradio_ai_chatbot_dotenv.py
-#
-# The script will output a local URL and potentially a public Gradio link.
-import gradio as gr
-from langchain_openai import ChatOpenAI
-from langchain.prompts import ChatPromptTemplate
-import os
-from dotenv import load_dotenv
-# --- Load environment variables from .env file ---
-load_dotenv()
-# --- Global variables and Initial Setup ---
-OPENAI_API_KEY_GLOBAL = os.getenv("OPENAI_API_KEY")
-LANGCHAIN_LLM = None
-LANGCHAIN_PROMPT_TEMPLATE = None
-INITIAL_AI_SETUP_MESSAGE = "" # To store status/error from initial setup
-def initialize_ai_components():
-    """
-    Initializes LangChain components (LLM and prompt template) using the API key
-    from environment variables. Updates global variables and sets a status message.
-    """
-    global LANGCHAIN_LLM, LANGCHAIN_PROMPT_TEMPLATE, OPENAI_API_KEY_GLOBAL, INITIAL_AI_SETUP_MESSAGE
-    if not OPENAI_API_KEY_GLOBAL:
-        INITIAL_AI_SETUP_MESSAGE = "<p style='color:red; font-weight:bold;'>ERROR: OpenAI API Key not found. Please ensure it's in your .env file or environment variables.</p>"
-        print("ERROR: OpenAI API Key not found. Make sure it's in your .env file or environment.")
-        return False # Indicate failure
-    try:
-        # Initialize the LangChain LLM (OpenAI model)
-        LANGCHAIN_LLM = ChatOpenAI(openai_api_key=OPENAI_API_KEY_GLOBAL, model_name="gpt-4o-mini")
-        # Define the prompt template for the LLM
-        prompt_template_str = """
-        You are a helpful, friendly, and insightful AI assistant.
-        Answer the user's question clearly, concisely, and in a conversational tone.
-        If you don't know the answer or a question is ambiguous, ask for clarification or state that you don't know.
-        User Question: {user_input}
-        AI Response:
-        """
-        LANGCHAIN_PROMPT_TEMPLATE = ChatPromptTemplate.from_template(prompt_template_str)
-        INITIAL_AI_SETUP_MESSAGE = "<p style='color:green; font-weight:bold;'>AI Components Initialized Successfully! Ready to chat.</p>"
-        print("AI Components Initialized Successfully!")
-        return True # Indicate success
-    except Exception as e:
-        INITIAL_AI_SETUP_MESSAGE = f"<p style='color:red; font-weight:bold;'>ERROR: Failed to initialize AI components. Error: {str(e)}. Please check your API key and model access.</p>"
-        LANGCHAIN_LLM = None
-        LANGCHAIN_PROMPT_TEMPLATE = None
-        print(f"ERROR: Failed to initialize AI components: {str(e)}")
-        return False # Indicate failure
-# --- Attempt to initialize AI components when the script loads ---
-AI_INITIALIZED_SUCCESSFULLY = initialize_ai_components()
-def ai_chat_response_function(user_message, chat_history):
-    """
-    This is the core function called by Gradio's ChatInterface.
-    It takes the user's message and the chat history, and returns the AI's response string.
-    """
-    if not AI_INITIALIZED_SUCCESSFULLY or not LANGCHAIN_LLM or not LANGCHAIN_PROMPT_TEMPLATE:
-        # Use the globally set error message from initialization
-        # Clean up HTML for plain error string if needed, or pass raw if Markdown supports it
-        error_msg_text = INITIAL_AI_SETUP_MESSAGE.replace("<p style='color:red; font-weight:bold;'>", "").replace("</p>", "")
-        return f"ERROR: AI is not ready. Status: {error_msg_text}"
-    # Proceed with generating response if components are ready
-    try:
-        # Create the LangChain chain (Prompt + LLM)
-        chain = LANGCHAIN_PROMPT_TEMPLATE | LANGCHAIN_LLM
-        # Invoke the chain with the user's input
-        ai_response = chain.invoke({"user_input": user_message})
-        # Return the content of the AI's response
-        return ai_response.content
-    except Exception as e:
-        print(f"Error during LangChain invocation: {e}") # Log for server-side debugging
-        return f"Sorry, an error occurred while trying to get a response: {str(e)}"
-# --- Gradio Interface Definition using gr.Blocks for layout control ---
-with gr.Blocks(theme=gr.themes.Soft(primary_hue=gr.themes.colors.blue, secondary_hue=gr.themes.colors.sky), title="AI Chatbot (Gradio)") as gradio_app:
-    gr.Markdown(
-        """
-        # 🤖 G34: AI Chatbot with Gradio, LangChain & OpenAI
-        Powered by OpenAI's `gpt-4o-mini` model.
-        OpenAI API Key is loaded from your `.env` file.
-        """
-    )
-    # Display the initial AI setup status
-    gr.Markdown(INITIAL_AI_SETUP_MESSAGE)
-    gr.Markdown("---") # Visual separator
-    gr.Markdown("## Chat Interface")
-    # Gradio ChatInterface for the main chat functionality
-    chat_interface_component = gr.ChatInterface(
-        fn=ai_chat_response_function, # The function that handles chat logic
-        chatbot=gr.Chatbot(
-            height=550,
-            show_label=False,
-            placeholder="AI's responses will appear here." if AI_INITIALIZED_SUCCESSFULLY else "AI is not available. Check setup status above.",
-            avatar_images=("https://raw.githubusercontent.com/svgmoji/svgmoji/main/packages/svgmoji__openmoji/svg/1F468-1F3FB-200D-1F9B0.svg", "https://raw.githubusercontent.com/gradio-app/gradio/main/gradio/icons/huggingface-logo.svg"),
-            type='messages'
-        ),
-        textbox=gr.Textbox(
-            placeholder="Type your message here and press Enter...",
-            show_label=False,
-            scale=7,
-            # Disable textbox if AI did not initialize successfully
-            interactive=AI_INITIALIZED_SUCCESSFULLY
-        ),
-        submit_btn="➡️ Send" if AI_INITIALIZED_SUCCESSFULLY else None, # Hide button if not ready
-        examples=[
-            "What is Paris, France known for?",
-            "Explain the concept of a Large Language Model (LLM) simply.",
-            "Can you give me a basic recipe for brownies?",
-            "Tell me an interesting fact about sunflowers."
-        ] if AI_INITIALIZED_SUCCESSFULLY else None, # Only show examples if AI is ready
-        title=None,
-        autofocus=True
-    )
-    # If AI initialization failed, you might want to make the ChatInterface non-interactive.
-    # One way is to conditionally enable/disable components or hide buttons as done above.
-    if not AI_INITIALIZED_SUCCESSFULLY:
-        # Further disable parts of the chat interface if needed, though ChatInterface
-        # doesn't have a simple 'interactive=False' for the whole thing.
-        # Hiding buttons and disabling textbox is a good start.
-        # The error message in `ai_chat_response_function` will also prevent interaction.
-        pass
-# --- Main execution block to launch the Gradio app ---
-if __name__ == '__main__':
-    print("Attempting to launch Gradio App...")
-    if not OPENAI_API_KEY_GLOBAL:
-        print("WARNING: OpenAI API Key was not found in environment variables or .env file.")
-        print("The application UI will launch, but AI functionality will be disabled.")
-        print("Please create a .env file with your OPENAI_API_KEY.")
-    gradio_app.launch(share=True, debug=True)

hf_streamlit_ai_app.py DELETED Viewed

@@ -1,128 +0,0 @@
-# Block 2: Create the Streamlit Application File (app.py)
-import streamlit as st
-from langchain_openai import ChatOpenAI
-from langchain.prompts import ChatPromptTemplate
-# --- Page Configuration ---
-st.set_page_config(
-    page_title="AI Chat Assistant",
-    page_icon="🤖",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-st.title("🤖 Streamlit AI Chat Assistant")
-st.markdown("""
-Welcome! Ask any question to the AI assistant. This application uses OpenAI's `gpt-4o-mini` model.
-Enter your OpenAI API Key in the sidebar to begin.
-""")
-# --- API Key Handling ---
-openai_api_key = None
-# Attempt to get API key from st.secrets (for deployed apps)
-try:
-    openai_api_key = st.secrets["OPENAI_API_KEY"]
-    if openai_api_key:
-        st.sidebar.success("API key loaded from st.secrets!")
-    else: # Handle case where secret exists but is empty
-        st.sidebar.warning("OpenAI API Key found in st.secrets but it's empty. Please provide a valid key.")
-except (KeyError, FileNotFoundError): # FileNotFoundError for local st.secrets.toml if used
-    st.sidebar.info("OpenAI API Key not found in st.secrets. Please enter it below for this session.")
-# Fallback to user input if not found in secrets or if secret was empty
-if not openai_api_key:
-    openai_api_key_input = st.sidebar.text_input(
-        "Enter your OpenAI API Key:",
-        type="password",
-        key="api_key_input_sidebar",
-        help="Your API key is used only for this session and not stored."
-    )
-    if openai_api_key_input:
-        openai_api_key = openai_api_key_input
-if not openai_api_key:
-    st.warning("Please provide your OpenAI API Key in the sidebar to use the chat.")
-    st.stop() # Stop execution if no API key is available
-# --- LangChain Setup (Cached for efficiency) ---
-@st.cache_resource # Caches the LLM and prompt template
-def get_langchain_components(_api_key_for_cache): # Parameter ensures cache reacts to API key changes if necessary
-    """Initializes and returns the LangChain LLM and prompt template."""
-    llm = ChatOpenAI(openai_api_key=_api_key_for_cache, model_name="gpt-4o-mini")
-    prompt_template_str = """
-    You are a knowledgeable and friendly AI assistant.
-    Your goal is to provide clear, concise, and helpful answers to the user's questions.
-    If you don't know the answer to a specific question, it's better to say so rather than inventing one.
-    User Question: {user_input}
-    AI Response:
-    """
-    prompt = ChatPromptTemplate.from_template(prompt_template_str)
-    return llm, prompt
-try:
-    llm, prompt_template = get_langchain_components(openai_api_key)
-except Exception as e:
-    st.error(f"Failed to initialize AI components. Error: {e}. Check your API key and model access.")
-    st.stop()
-# --- Initialize session state for storing chat messages ---
-if "messages" not in st.session_state:
-    st.session_state.messages = []
-# --- Display existing chat messages ---
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
-# --- Chat Input and AI Response Logic ---
-if user_query := st.chat_input("What would you like to ask?"):
-    # Add user message to session state and display it
-    st.session_state.messages.append({"role": "user", "content": user_query})
-    with st.chat_message("user"):
-        st.markdown(user_query)
-    # Get and display AI response
-    with st.chat_message("assistant"):
-        message_placeholder = st.empty() # For "Thinking..." message and then the actual response
-        with st.spinner("AI is thinking..."):
-            try:
-                chain = prompt_template | llm
-                ai_response_message = chain.invoke({"user_input": user_query})
-                ai_response_content = ai_response_message.content
-                message_placeholder.markdown(ai_response_content)
-                # Add AI response to session state
-                st.session_state.messages.append({"role": "assistant", "content": ai_response_content})
-            except Exception as e:
-                error_message = f"Sorry, I encountered an error: {str(e)}"
-                message_placeholder.error(error_message)
-                st.session_state.messages.append({"role": "assistant", "content": error_message})
-# --- Sidebar Options ---
-with st.sidebar:
-    st.divider()
-    if st.button("Clear Chat History", key="clear_chat"):
-        st.session_state.messages = []
-        st.success("Chat history cleared!")
-        st.rerun() # Rerun to update the UI immediately
-    st.markdown("---")
-    st.subheader("About")
-    st.info(
-        "This is a Streamlit application demonstrating an AI chat interface "
-        "using LangChain and OpenAI's gpt-4o-mini model."
-    )
-# --- Block 3: Run the Streamlit Application ---
-# To start your streamlit app, run the following command in your terminal:
-# streamlit run hf_streamlit_ai_app.py
-# Make sure you have the required packages installed:
-# pip install streamlit langchain openai langchain_openai -q

localhost_ai_app.py DELETED Viewed

@@ -1,97 +0,0 @@
-# localhost_ai_app.py
-# # Block 1: Set up dependencies
-# On a local machine, you would typically run this in your terminal inside a virtual environment to install the necessary packages.
-# \!pip install flask langchain openai python-dotenv langchain_openai -q -q -q
-# # Block 2: Import Libraries and Configure API Key
-# import the dependencies
-import os
-from flask import Flask, request, jsonify
-from langchain_openai import ChatOpenAI
-from langchain.prompts import ChatPromptTemplate
-from dotenv import load_dotenv
-# Load environment variables from .env file
-load_dotenv()
-# --- OpenAI API Key Configuration ---
-# This relies on the OPENAI_API_KEY being set in your .env file
-api_key = os.getenv("OPENAI_API_KEY")
-# # Block 3: Define Prompt Template and Initialize LangChain with OpenAI
-# Initialize the OpenAI LLM
-# You can choose different models
-# The script will fail here if api_key is None (i.e., not found in .env)
-# OPENAI MODEL REFERENCE - (https://platform.openai.com/docs/models)
-llm = ChatOpenAI(openai_api_key=api_key, model_name="gpt-4o-mini")
-# Define the prompt template
-# This template instructs the AI and includes a placeholder for user input.
-prompt_template_str = """
-You are a helpful AI assistant. Answer the user's question clearly and concisely.
-User Question: {user_input}
-AI Response:
-"""
-prompt_template = ChatPromptTemplate.from_template(prompt_template_str)
-print("LangChain components initialized.")
-# Block 4: Set up Flask Application and Implement Chat Endpoint
-# --- Set up Flask Application ---
-app = Flask(__name__)
-print("Flask application created.")
-@app.route('/chat', methods=['POST'])
-def chat_endpoint():
-    try:
-        data = request.get_json()
-        if not data or 'user_input' not in data:
-            return jsonify({"error": "No user_input provided in JSON payload."}), 400
-        user_input = data['user_input']
-        # Create the LangChain chain (Prompt + LLM)
-        # LCEL (LangChain Expression Language) is used here
-        chain = prompt_template | llm
-        # Invoke the chain with the user's input
-        ai_response_message = chain.invoke({"user_input": user_input})
-        # The response from ChatOpenAI is an AIMessage object, access its content
-        ai_response_content = ai_response_message.content
-        return jsonify({"ai_response": ai_response_content})
-    except Exception as e:
-        # Log the error for debugging on the server side
-        print(f"Error processing request: {e}") # Basic logging
-        return jsonify({"error": "An error occurred while processing your request.", "details": str(e)}), 500
-print("Flask /chat endpoint configured.")
-# # Block 5: Run Locally (Start the Flask Server)
-# Steps to run the Flask application:
-# 1. Activate your virtual environment.
-# 2. Enter "python3 localhost_ai_app.py" into your terminal.
-# 3. In a new terminal, with your flask server running, enter "curl -X POST -H "Content-Type: application/json" -d '{"user_input":"Hello, AI! Whats the capital of Norway?"}' http://127.0.0.1:8000/chat"
-# --- Run Flask Application ---
-if __name__ == '__main__':
-    if not api_key:
-        print("--------------------------------------------------------------------")
-        print("ERROR: OpenAI API key not found.")
-        print("Please create a .env file in the same directory as this script with:")
-        print("OPENAI_API_KEY=\"your_openai_api_key_here\"")
-        print("--------------------------------------------------------------------")
-    else:
-        print("Starting Flask server...")
-        # host='0.0.0.0' makes it accessible from your network, not just localhost
-        # debug=True is useful for development, provides more error details
-        app.run(host='0.0.0.0', port=8000, debug=True)

streamlit_requirements.txt DELETED Viewed

@@ -1,4 +0,0 @@
-streamlit
-langchain
-openai
-langchain_openai