Example: How Contextual Search Enhances Results

Using Perplexity API with Python Script to demonstrate how to create the contextual search optimization

1. Obtain OpenAI API Key and Perplexity API Key

   • OpenAI API Key

     • Visit the OpenAI API signup page at this link.

     • Sign in or create an OpenAI account if you don’t have one.

     • In the API Keys section, click on “Create new secret key” to generate a new API key.

     • Copy this key and keep it in a secure place.

   • Perplexity API Key

     • Visit the Perplexity API initial setup guide at this link.

     • Follow the instructions on the page to sign up and obtain your unique Perplexity API key.

     • Copy this key and keep it in a secure place.

2. Access the Notebook

   • Copy the notebook from the provided Google Colab link: Unleashing Knowledge Through Intelligent Conversations.ipynb.

   • Click on "File" > "Save a copy in Drive" to save it to your Google Drive.

3. Customize the Script

   • Open the notebook in Google Colab and locate the section “# === Configuration ===” where you need to input your OpenAI and Perplexity API keys.

   • Replace the placeholder YOUR_OPENAI_API_KEY and YOUR_PERPLEXITY_API_KEY with the actual API keys you obtained earlier.

4. Run the Notebook

   • Execute the code cells in the notebook by pressing Shift + Enter or using the "Run" button in Google Colab.

   • The notebook will send requests to the Perplexity API and display results based on the queries you provide.

5. Adjust and Experiment

   • Feel free to modify the queries, context, or any other parameters to suit your needs.

   • You can explore the API documentation for additional features or to refine your search results.

import requests
import json

# === Configuration ===
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY"
PERPLEXITY_API_KEY = "YOUR_PERPLEXITY_API_KEY"


# Base URLs
OPENAI_BASE_URL = "https://api.openai.com"
PERPLEXITY_BASE_URL = "https://api.perplexity.ai"

# Model settings
OPENAI_MODEL = "gpt-4o-mini"  # Model used to generate clarifying questions
# For Perplexity, we now use the sonar-pro model via the chat/completions endpoint.
PERPLEXITY_MODEL = "sonar-pro"

def generate_single_question(conversation):
    """
    Generate a single clarifying question based on the current conversation context.
    """
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}",
        "Content-Type": "application/json"
    }
    data = {
        "model": OPENAI_MODEL,
        "messages": conversation,
        "max_tokens": 150,
        "temperature": 0.7
    }
    
    endpoint = f"{OPENAI_BASE_URL}/v1/chat/completions"
    response = requests.post(endpoint, headers=headers, json=data)
    response.raise_for_status()
    
    result = response.json()
    question = result["choices"][0]["message"]["content"].strip()
    # Remove numbering if present
    if question and question[0].isdigit():
        question = question.lstrip("0123456789. )")
    return question

def submit_to_perplexity(final_data):
    """
    Submit the final JSON structure to the Perplexity API using the chat/completions method.
    The final_data (a dict) is converted to a JSON string and sent as the user message.
    The system prompt instructs the assistant to provide a markdown-formatted search result
    that includes citations (references) at the end.
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {PERPLEXITY_API_KEY}"
    }
    
    messages = [
        {
            "role": "system",
            "content": (
                "You are a search assistant. Provide your output in markdown format with clear headings, "
                "bullet points, and a references section at the end that lists citations as in-line links. "
                "Do not include any JSON formatting in your output."
            )
        },
        {
            "role": "user",
            "content": json.dumps(final_data, indent=2)
        }
    ]
    
    payload = {
        "model": PERPLEXITY_MODEL,
        "messages": messages,
        "max_tokens": "8192",
        "temperature": 0.2,
        "top_p": 0.9,
        "search_domain_filter": ["perplexity.ai"],
        "return_images": False,
        "return_related_questions": False,
        "search_recency_filter": "month",
        "top_k": 0,
        "stream": False,
        "presence_penalty": 0,
        "frequency_penalty": 1,
        "response_format": None
    }
    
    endpoint = f"{PERPLEXITY_BASE_URL}/chat/completions"
    response = requests.post(endpoint, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()

def main():
    # Step 1: Get the initial query from the user.
    initial_query = input("Enter your initial query: ").strip()
    
    # Set up the initial conversation context for generating clarifying questions.
    conversation = [
        {
            "role": "system",
            "content": (
                "You are a search optimizer. Analyze the user's query and identify any missing details "
                "needed for a high-quality search. Generate a clarifying question and wait for the user's answer "
                "before asking the next question."
            )
        },
        {
            "role": "user",
            "content": f"My query is: \"{initial_query}\""
        }
    ]
    
    context = []  # List to store follow-up question and answer pairs
    
    # Step 2: Generate 3 clarifying questions one at a time.
    for i in range(3):
        try:
            question = generate_single_question(conversation)
        except Exception as e:
            print("Error generating question:", e)
            return
        print(f"\nClarifying Question {i+1}: {question}")
        user_answer = input("Your answer: ").strip()
        
        # Append to conversation for context.
        conversation.append({"role": "assistant", "content": question})
        conversation.append({"role": "user", "content": user_answer})
        
        # Save the Q&A pair.
        context.append({
            "followup_question": question,
            "user_answer": user_answer
        })
    
    # Step 3: Build the final JSON structure.
    final_json = {
        "initial_user_query": initial_query,
        "context": context
    }
    
    print("\nFinal JSON structure to be submitted to Perplexity API:")
    print(json.dumps(final_json, indent=2))
    
    # Step 4: Submit the JSON structure to the Perplexity API.
    try:
        perplexity_result = submit_to_perplexity(final_json)
        # Extract the markdown-formatted result from the response.
        # Assuming the response structure is similar to OpenAI's chat completions response:
        markdown_result = perplexity_result["choices"][0]["message"]["content"].strip()
        print("\nSearch Results (Markdown Format):\n")
        print(markdown_result)
    except Exception as e:
        print("Error submitting to Perplexity API:", e)

if __name__ == "__main__":
    main()

Python Script Architecture

This script implements a two-step search assistant that combines the power of two APIs:

• OpenAI API (using a fast and affordable small model called gpt-4o-mini) to generate clarifying questions about an initial user query.

• Perplexity API (using the sonar-pro model) to perform a search based on the enriched context built from the initial query and follow-up answers.

The final output is a markdown-formatted search result with citations.

Key Components

1. Configuration and API Endpoints

• API Keys:

  You need to supply your own API keys by replacing "YOUR_OPENAI_API_KEY" and "YOUR_PERPLEXITY_API_KEY".

• Base URLs and Models:

  • The OpenAI base URL is set to "<https://api.openai.com>".

  • The Perplexity base URL is "<https://api.perplexity.ai>".

  • The script uses the gpt-4o-mini model to generate clarifying questions.

  • For the Perplexity API, it uses the sonar-pro model via the chat/completions endpoint.

2. Function: generate_single_question(conversation)

• Purpose: This function sends the current conversation (including the initial query and any prior clarifying answers) to the OpenAI API.

• How It Works:

  • A POST request is made to the OpenAI chat completions endpoint with a JSON payload containing the conversation context.

  • It sets parameters such as max_tokens and temperature to control the response.

  • The returned response is parsed, and the content of the assistant’s message (i.e., the clarifying question) is extracted and cleaned of any numbering.

3. Function: submit_to_perplexity(final_data)

• Purpose: After gathering the initial query and clarifying question–answer pairs, this function builds a final JSON structure and submits it to the Perplexity API.

• How It Works:

  • The final JSON includes the initial user query and the context of follow-up Q&A pairs.

  • A system message instructs the Perplexity model to return a markdown-formatted response with clear headings, bullet points, and inline citations.

  • A POST request is sent to the Perplexity chat/completions endpoint using the provided payload and parameters such as max_tokens, temperature, and top_p.

4. Function: main()

• User Interaction:

  • The script first prompts the user for an initial query.

  • It sets up an initial conversation context for generating clarifying questions.

• Clarifying Questions Loop:

  • The script generates three clarifying questions sequentially.

  • For each question, it prints the question to the user, then waits for an answer.

  • Both the question and the user’s answer are added to the conversation context.

• Final Submission:

  • After collecting all the clarifying details, it builds a JSON structure containing the initial query and all the context.

  • This JSON is printed (for debugging or confirmation) before being submitted to the Perplexity API.

  • The markdown result returned by the Perplexity API is then printed out.

Workflow Summary

1. Initial Query:

   The user inputs their search query.

2. Clarifying Questions Generation:

   The script leverages the OpenAI API to generate clarifying questions. It then collects user answers, enriching the context.

3. Context Building:

   The initial query along with all the clarifying question–answer pairs are compiled into a final JSON structure.

4. Submission to Perplexity API:

   This JSON is sent to the Perplexity API. The API uses the context to generate a detailed, markdown-formatted search result that includes clear headings, bullet points, and citations.

5. Output:

   The markdown result is displayed to the user.

 
# How to Invest in AI Companies - Search Results

## Initial Query

"How to invest in AI startup?"

## Clarifying Questions & Answers

### Question 1

Q: To provide you with the most relevant and useful information, could you clarify whether you're looking for general investment advice, specific platforms or ways to find AI startups to invest in, or information on investment strategies related to AI startups?

A: Ways to find AI startups to invest in

### Question 2

Q: Could you specify if you're interested in investing in early-stage startups, established companies, or a mix of both? Additionally, are you looking for resources in a specific geographic area or region?

A: Established companies

### Question 3

Q: Are you looking for publicly traded companies, or are you also interested in private companies that may be seeking investment?

A: Publicly traded companies

## Investment Options

### AI-Focused Stock Indices and ETFs

- The Morningstar Global Next Generation Artificial Intelligence Index tracks top AI companies
    - Notable constituents: Microsoft, Alphabet, Oracle, Advanced Micro Devices[3]
- AI-focused ETFs offer diversified exposure through single investment vehicles

### Individual AI Stocks

Top publicly traded options include:

- Microsoft (MSFT): Leader in AI with OpenAI/ChatGPT integration[3]
- Alphabet (GOOGL): Google's parent company, AI frontrunner[3]
- NVIDIA (NVDA): Major player in AI chips and infrastructure[1]
- SoundHound AI (SOUN): Voice AI technology specialist[1][5]
- Palantir Technologies (PLTR): AI-powered data analytics platforms[5]

### AI Investment Platforms

Specialized platforms for AI investment opportunities:

- Magnifi: AI-powered platform matching investors with AI stocks and funds[4]
- Forge: Platform for private company shares trading[10]

### Key Considerations

When investing in AI companies:

- **Diversification**: Mix established tech giants with specialized AI firms
- **Research**: Investigate AI capabilities, market position, and financial health
- **Long-term outlook**: Focus on sustainable competitive advantages

*Note: Consult with a financial advisor to align investments with your goals and risk tolerance.*

Practical Considerations

• API Rate Limits and Errors:

  The script uses response.raise_for_status() to handle HTTP errors, which means any issues with the API calls (such as rate limits or authentication problems) will stop the script and print an error message.

• Customization:

  You can adjust parameters like max_tokens, temperature, and top_p to fine-tune the behavior of both APIs.

• Formatting:

  The Perplexity API is expected to return search results in a nicely formatted markdown style, complete with citations. This is controlled by the system prompt in the submit_to_perplexity function.

This code is a good starting point if you want to build an interactive search assistant that not only processes an initial query but also improves the quality of the search via clarifying questions. You can further enhance it by adding more robust error handling, logging, or additional API parameters based on your requirements.