OpenAI Assistants Integration

import streamlit as st
import openai
import time

st.title("🔍 AI Research Assistant")
st.caption("Powered by OpenAI GPT-4 + SearchHive APIs")

# Initialize session state
if "messages" not in st.session_state:
    st.session_state.messages = []
if "thread_id" not in st.session_state:
    st.session_state.thread_id = None

# Initialize clients
client = openai.OpenAI(api_key=st.secrets["OPENAI_API_KEY"])
ASSISTANT_ID = "asst_your_assistant_id"

def create_thread():
    """Create a new conversation thread"""
    thread = client.beta.threads.create()
    return thread.id

def run_assistant(thread_id, user_message):
    """Run the assistant with SearchHive integration"""
    # Add user message
    client.beta.threads.messages.create(
        thread_id=thread_id,
        role="user",
        content=user_message
    )
    
    # Start the run
    run = client.beta.threads.runs.create(
        thread_id=thread_id,
        assistant_id=ASSISTANT_ID
    )
    
    # Handle the conversation with function calls
    while run.status in ['queued', 'in_progress', 'requires_action']:
        if run.status == 'requires_action':
            # Handle SearchHive function calls
            tool_calls = run.required_action.submit_tool_outputs.tool_calls
            tool_outputs = []
            
            for tool_call in tool_calls:
                function_name = tool_call.function.name
                function_args = json.loads(tool_call.function.arguments)
                
                with st.spinner(f"🔍 {function_name.replace('_', ' ').title()}..."):
                    if function_name == "search_web":
                        result = search_web(
                            query=function_args["query"],
                            max_results=function_args.get("max_results", 10)
                        )
                        st.sidebar.success(f"Found {len(result.get('search_results', []))} search results")
                        
                    elif function_name == "scrape_webpage":
                        result = scrape_webpage(url=function_args["url"])
                        st.sidebar.success(f"Scraped webpage: {function_args['url']}")
                    
                    tool_outputs.append({
                        "tool_call_id": tool_call.id,
                        "output": json.dumps(result)
                    })
            
            # Submit the function outputs
            run = client.beta.threads.runs.submit_tool_outputs(
                thread_id=thread_id,
                run_id=run.id,
                tool_outputs=tool_outputs
            )
        
        time.sleep(1)
        run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)
    
    # Get the assistant's response
    messages = client.beta.threads.messages.list(thread_id=thread_id)
    return messages.data[0].content[0].text.value

# Create thread if needed
if st.session_state.thread_id is None:
    st.session_state.thread_id = create_thread()

# Display chat history
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# Chat input
if prompt := st.chat_input("Ask me to research anything..."):
    # Add user message to history
    st.session_state.messages.append({"role": "user", "content": prompt})
    
    with st.chat_message("user"):
        st.markdown(prompt)
    
    # Get assistant response
    with st.chat_message("assistant"):
        with st.spinner("Researching..."):
            response = run_assistant(st.session_state.thread_id, prompt)
            st.markdown(response)
            
        # Add assistant response to history
        st.session_state.messages.append({"role": "assistant", "content": response})

# Sidebar with examples
st.sidebar.header("💡 Example Queries")
st.sidebar.markdown("""
- "What are the latest AI breakthroughs this month?"
- "Research the current state of renewable energy adoption"
- "Find recent news about cryptocurrency regulations"
- "Analyze the latest trends in remote work"
- "What are experts saying about climate change solutions?"
""")

st.sidebar.header("🔧 Functions Available")
st.sidebar.markdown("""
- **Web Search**: Real-time search across the internet
- **Webpage Scraping**: Extract content from any URL
- **AI Analysis**: GPT-4 powered insights and summaries
"")

const OpenAI = require('openai');
const axios = require('axios');

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

const SEARCHHIVE_API_KEY = process.env.SEARCHHIVE_API_KEY;

// SearchHive function implementations
async function searchWeb(query, maxResults = 10) {
  try {
    const response = await axios.post(
      'https://www.searchhive.dev/api/v1/swiftsearch',
      {
        query: query,
        max_results: maxResults
      },
      {
        headers: {
          'Authorization': `Bearer ${SEARCHHIVE_API_KEY}`
        }
      }
    );
    return response.data;
  } catch (error) {
    return { error: error.message };
  }
}

async function scrapeWebpage(url) {
  try {
    const response = await axios.post(
      'https://www.searchhive.dev/api/v1/scrapeforge',
      {
        url: url,
        extract_options: ['title', 'text', 'metadata']
      },
      {
        headers: {
          'Authorization': `Bearer ${SEARCHHIVE_API_KEY}`
        }
      }
    );
    return response.data;
  } catch (error) {
    return { error: error.message };
  }
}

// Create assistant
async function createResearchAssistant() {
  const assistant = await openai.beta.assistants.create({
    name: "Web Research Assistant",
    instructions: `You are a research assistant with real-time web access. 
    Use search_web to find current information and scrape_webpage to get detailed content from URLs.
    Always cite your sources and provide accurate, up-to-date information.`,
    model: "gpt-4-turbo-preview",
    tools: [
      {
        type: "function",
        function: {
          name: "search_web",
          description: "Search the web for current information",
          parameters: {
            type: "object",
            properties: {
              query: { type: "string", description: "Search query" },
              maxResults: { type: "integer", description: "Max results (default: 10)" }
            },
            required: ["query"]
          }
        }
      },
      {
        type: "function",
        function: {
          name: "scrape_webpage", 
          description: "Extract content from a webpage URL",
          parameters: {
            type: "object",
            properties: {
              url: { type: "string", description: "URL to scrape" }
            },
            required: ["url"]
          }
        }
      }
    ]
  });
  
  return assistant;
}

// Handle conversation with function calls
async function runConversation(assistantId, userMessage) {
  // Create thread
  const thread = await openai.beta.threads.create();
  
  // Add message
  await openai.beta.threads.messages.create(thread.id, {
    role: "user",
    content: userMessage
  });
  
  // Run assistant
  let run = await openai.beta.threads.runs.create(thread.id, {
    assistant_id: assistantId
  });
  
  // Handle function calls
  while (run.status === 'queued' || run.status === 'in_progress' || run.status === 'requires_action') {
    if (run.status === 'requires_action') {
      const toolCalls = run.required_action.submit_tool_outputs.tool_calls;
      const toolOutputs = [];
      
      for (const toolCall of toolCalls) {
        const functionName = toolCall.function.name;
        const args = JSON.parse(toolCall.function.arguments);
        
        let result;
        if (functionName === 'search_web') {
          result = await searchWeb(args.query, args.maxResults);
        } else if (functionName === 'scrape_webpage') {
          result = await scrapeWebpage(args.url);
        }
        
        toolOutputs.push({
          tool_call_id: toolCall.id,
          output: JSON.stringify(result)
        });
      }
      
      run = await openai.beta.threads.runs.submitToolOutputs(
        thread.id,
        run.id,
        { tool_outputs: toolOutputs }
      );
    }
    
    await new Promise(resolve => setTimeout(resolve, 1000));
    run = await openai.beta.threads.runs.retrieve(thread.id, run.id);
  }
  
  // Get response
  const messages = await openai.beta.threads.messages.list(thread.id);
  return messages.data[0].content[0].text.value;
}

// Example usage
async function main() {
  const assistant = await createResearchAssistant();
  console.log(`Assistant created: ${assistant.id}`);
  
  const response = await runConversation(
    assistant.id,
    "What are the latest developments in quantum computing? Please search for recent news and provide a comprehensive summary."
  );
  
  console.log("Assistant Response:", response);
}

main().catch(console.error);