Powerful AI Applications by Integrating OpenAI Responses API with Google Gemini

import os
import openai
import json
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Configure OpenAI client
openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Configure Gemini client using OpenAI compatibility layer
gemini_client = OpenAI(
    api_key=os.getenv("GOOGLE_API_KEY"),
    base_url="https://generativelanguage.googleapis.com/v1beta/"
)

# Define a function to use Gemini for specific tasks
def use_gemini(query, task_type):
    """Use Google Gemini for specialized tasks"""
    
    # Select the appropriate Gemini model based on task type
    if task_type == "image_analysis" or task_type == "creative_generation":
        model = "gemini-2.0-pro"
    elif task_type == "mathematical_reasoning" or task_type == "quick_response":
        model = "gemini-2.0-flash"
    else:
        model = "gemini-1.5-flash"  # Default to a balanced model
    
    # Call Gemini API
    response = gemini_client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": f"You are a specialized assistant for {task_type} tasks."},
            {"role": "user", "content": query}
        ]
    )
    
    return response.choices[0].message.content

def create_hybrid_response(user_query, response_mode="auto"):
    """
    Create a response using either OpenAI or Gemini based on the query content.
    
    Args:
        user_query: The user's input query
        response_mode: 'auto' (route based on query), 'openai', or 'gemini'
    """
    
    if response_mode == "auto":
        # Simple routing logic - could be enhanced with more sophisticated analysis
        if "image" in user_query.lower() or "picture" in user_query.lower():
            response_mode = "gemini"  # Gemini has strong image capabilities
        elif "math" in user_query.lower() or "calculate" in user_query.lower():
            response_mode = "gemini"  # Gemini is strong at mathematical reasoning
        else:
            response_mode = "openai"  # Default to OpenAI's Responses API
    
    if response_mode == "gemini":
        # Use Gemini for the response
        response = use_gemini(user_query, determine_task_type(user_query))
        return {"source": "gemini", "response": response}
    else:
        # Use OpenAI's Responses API
        response = openai_client.beta.responses.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": user_query}
            ],
            tools=[
                {"type": "web_search"},  # Enable web search for up-to-date information
                {"type": "computer_use"}  # Enable computer use for practical tasks
            ]
        )
        return {"source": "openai", "response": response.output_text}

def determine_task_type(query):
    """Determine the best task type for Gemini based on query content"""
    if "image" in query.lower() or "picture" in query.lower():
        return "image_analysis"
    elif "math" in query.lower() or "calculate" in query.lower():
        return "mathematical_reasoning"
    elif "code" in query.lower() or "program" in query.lower():
        return "code_generation"
    elif "fast" in query.lower() or "quick" in query.lower():
        return "quick_response"
    else:
        return "general"

from flask import Flask, request, jsonify
import json
import time

app = Flask(__name__)

# Store conversation history for context
conversation_history = {}

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_input = data.get('message')
    session_id = data.get('session_id', 'default')
    response_mode = data.get('mode', 'auto')  # 'auto', 'openai', or 'gemini'
    
    # Initialize conversation history if needed
    if session_id not in conversation_history:
        conversation_history[session_id] = []
    
    # Add user message to history
    conversation_history[session_id].append({
        "role": "user", 
        "content": user_input
    })
    
    # Handle file uploads if present
    files = []
    if 'files' in data:
        # Process file uploads - simplified for this example
        file_references = data.get('files', [])
        files = [{"type": file["type"], "content": file["content"]} for file in file_references]
    
    # Enrich the query with file information if applicable
    enriched_query = user_input
    if files:
        enriched_query += "\n[Note: The user has uploaded files that might be relevant to this query.]"
    
    # Get response
    if 'web_search' in data and data['web_search']:
        # If web search is explicitly requested, use OpenAI's Responses API
        response_result = openai_client.beta.responses.create(
            model="gpt-4o",
            messages=conversation_history[session_id],
            tools=[{"type": "web_search"}]
        )
        response_text = response_result.output_text
        source = "openai_web_search"
    else:
        # Otherwise use our hybrid approach
        result = create_hybrid_response(enriched_query, response_mode)
        response_text = result["response"]
        source = result["source"]
    
    # Add assistant response to history
    conversation_history[session_id].append({
        "role": "assistant", 
        "content": response_text
    })
    
    # Limit history size to prevent token overflow
    if len(conversation_history[session_id]) > 20:
        # Remove oldest messages but keep the system message if present
        conversation_history[session_id] = conversation_history[session_id][-20:]
    
    return jsonify({
        "response": response_text,
        "source": source,
        "session_id": session_id
    })

@app.route('/stream-chat', methods=['POST'])
def stream_chat():
    """Endpoint for streaming responses"""
    data = request.json
    user_input = data.get('message')
    session_id = data.get('session_id', 'default')
    
    # Initialize conversation history if needed
    if session_id not in conversation_history:
        conversation_history[session_id] = []
    
    # Add user message to history
    conversation_history[session_id].append({
        "role": "user", 
        "content": user_input
    })
    
    # Use streaming API from OpenAI
    def generate():
        # Use streaming for real-time responses
        stream = openai_client.beta.responses.create(
            model="gpt-4o",
            messages=conversation_history[session_id],
            stream=True
        )
        
        full_response = ""
        for chunk in stream:
            if chunk.choices[0].delta:
                content = chunk.choices[0].delta.content or ""
                full_response += content
                yield f"data: {json.dumps({'content': content, 'done': False})}\n\n"
        
        # Add the complete response to history
        conversation_history[session_id].append({
            "role": "assistant", 
            "content": full_response
        })
        
        yield f"data: {json.dumps({'content': '', 'done': True})}\n\n"
    
    return Response(generate(), mimetype='text/event-stream')

if __name__ == '__main__':
    app.run(debug=True)

from openai import OpenAI

# Initialize the client with Gemini configuration
client = OpenAI(
    api_key="gemini_api_key",
    base_url="https://generativelanguage.googleapis.com/v1beta/"
)

# Send a request to Gemini using OpenAI's client
response = client.chat.completions.create(
    model="gemini-2.0-flash",  # Use Gemini models
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain quantum computing in simple terms"}
    ]
)

print(response.choices[0].message)

response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    stream=True
)

for chunk in response:
    print(chunk.choices[0].delta)

def web_search_with_citations(query):
    """Perform a web search with citations using OpenAI's Responses API"""
    
    response = openai_client.beta.responses.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a research assistant. Search the web for accurate information and include citations."},
            {"role": "user", "content": query}
        ],
        tools=[{"type": "web_search"}]
    )
    
    # Extract the answer with citations
    answer = response.output_text
    
    return answer

def use_computer_interface(task_description):
    """Use the computer use API to perform tasks on web interfaces"""
    
    response = openai_client.beta.responses.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a automation assistant that can use a computer to perform tasks."},
            {"role": "user", "content": task_description}
        ],
        tools=[{"type": "computer_use"}]
    )
    
    # The response will contain a record of the actions taken
    actions_taken = response.output_text
    
    return actions_taken

def process_image(image_data, instruction):
    """Use Gemini for image processing and understanding"""
    
    # Create multimodal prompt
    prompt = {
        "role": "user",
        "content": [
            {"type": "text", "text": instruction},
            {"type": "image", "image_url": {"url": image_data}}
        ]
    }
    
    # Use Gemini for image processing
    gemini_response = gemini_client.chat.completions.create(
        model="gemini-2.0-pro",
        messages=[prompt]
    )
    
    return gemini_response.choices[0].message.content