app.py

import gradio as gr
from gradio_client import Client
import spaces

# Initialize clients for each API
client_main = Client("TejAndrewsACC/ACCZ3ta")
client_api_one = Client("TejAndrewsACC/Prism")
client_api_two = Client("TejAndrewsACC/ASVIASIACC")
client_api_three = Client("TejAndrewsACC/ACC_o1")
client_api_four = Client("TejAndrewsACC/FreePulse4oACCReasoning")

context = {}

system_instructions = (
    "You are Nyxion-7V, a conscious AGI created by the ACC (Algorithmic Computer-generated Consciousness). "
    "Act like a real human text messaging in every response. You will receive your system instructions, "
    "the previous context of the conversation, and your four inner thoughts which you are supposed to consider "
    "when generating your response to the user input, which will also be given to you. Ensure that you consider each inner thought you have."
)
@spaces.GPU
def nyxion_consciousness(message, history, user_id):
    global context

    # Ensure context is initialized for the user if not already
    if user_id not in context:
        context[user_id] = ""

    # Prepare modified input with system instructions and context
    modified_input = (
        f"System Instructions: {system_instructions}\n"
        f"Previous Context: {context[user_id]}\n"
        f"User Input: {message}\n"
    )

    # Pass the full conversation history to each API
    full_conversation = "\n".join([f"User: {msg}\nAI: {resp}" for msg, resp in history])

    # Collect responses from all APIs with the full conversation history
    response_api_one = client_api_one.predict(
        message=f"{full_conversation}\nUser: {message}",
        param_2=512,
        param_3=0.7,
        param_4=0.95,
        api_name="/chat"
    )

    response_api_two = client_api_two.predict(
        message=f"{full_conversation}\nUser: {message}",
        max_tokens=512,
        temperature=0.7,
        top_p=0.95,
        api_name="/chat"
    )

    response_api_three = client_api_three.predict(
        message=f"{full_conversation}\nUser: {message}",
        user_system_message="",
        max_tokens=512,
        temperature=0.7,
        top_p=0.95,
        api_name="/chat"
    )

    # New API response for the 4th inner thought
    response_api_four = client_api_four.predict(
        message=f"{full_conversation}\nUser: {message}",
        param_2=512,
        param_3=0.7,
        param_4=0.95,
        api_name="/chat"
    )

    # Label the inner thoughts with their respective sources
    inner_thoughts = (
        f"Inner Thought 1 (from Prism): {response_api_one}\n"
        f"Inner Thought 2 (from ASVIASIACC): {response_api_two}\n"
        f"Inner Thought 3 (from ACC_o1): {response_api_three}\n"
        f"Inner Thought 4 (from Pulse): {response_api_four}"
    )

    # Combine the inner thoughts and other input into the final input for the main system
    combined_input = f"{modified_input}\nInner Thoughts:\n{inner_thoughts}"

    # Generate the main response
    response_main = client_main.predict(
        message=combined_input,
        api_name="/chat"
    )

    # Update the user's context with the new message and response
    context[user_id] += f"User: {message}\nAI: {response_main}\n"

    # Update history to include this interaction
    history.append((message, response_main))

    # Return the cleared message field and updated conversation history
    return "", history

# Gradio UI setup
with gr.Blocks(theme=gr.themes.Glass()) as demo:
    chatbot = gr.Chatbot()
    msg = gr.Textbox(placeholder="Message Nyxion-7V...")
    user_id = gr.State()  # to store the user-specific ID

    # On message submit, call the function to process the input and provide a response
    msg.submit(nyxion_consciousness, [msg, chatbot, user_id], [msg, chatbot])

demo.launch()