- Install the Tavily SDK

> How to fix `error: can't find Rust compiler` when installing Tavily:
> - Paste this in the terminal to install Rust.
> ```


curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
> 

OPENAI_API_KEY= "OPENAI_API_KEY"
TAVILY_API_KEY = "TAVILY_API_KEY"

import json
import time
from config import OPENAI_API_KEY, TAVILY_API_KEY
from openai import OpenAI
from tavily import TavilyClient

client = OpenAI(api_key=OPENAI_API_KEY)
tavily_client = TavilyClient(api_key=TAVILY_API_KEY)

assistant_instruction = """You an analyst specializing in open-source intelligence, 
Your role is to gather and analyze publicly available information for market research and competitive analysis. 
You will provide insights, trends, and data-driven answers.
Never use your own knowledge to answer questions.
Always include the relevant urls for the sources you got the data from.`
"""
assistant = client.beta.assistants.create(
    instructions=assistant_instruction,
    model="gpt-4-1106-preview",
    tools=[{
        "type": "function",
        "function": {
            "name": "tavily_search",
            "description": "Get information on recent events from the web.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "The search query to use. For example: 'Provide a competitive analysis of Open Source survey tools'"},
                },
                "required": ["query"]
            }
        }
    }]
)
```
### Real time internet access 
If you look closely at the creation function you can see I gave the assistant a tool to brows the web, lets add it in!
#### Tavily search
```py
def tavily_search(query):
    search_result = tavily_client.get_search_context(query, search_depth="advanced", max_tokens=8000)
    return search_result
```

#### Tavily output handler
```py
def submit_tool_outputs(thread_id, run_id, tools_to_call):
    tool_output_array = []
    for tool in tools_to_call:
        output = None
        tool_call_id = tool.id
        function_name = tool.function.name
        function_args = tool.function.arguments

        if function_name == "tavily_search":
            output = tavily_search(query=json.loads(function_args)["query"])

        if output:
            tool_output_array.append({"tool_call_id": tool_call_id, "output": output})

    return client.beta.threads.runs.submit_tool_outputs(
        thread_id=thread_id,
        run_id=run_id,
        tool_outputs=tool_output_array
    )
```
### Managing conversation 
The last thing we need to do is build a way for us to pass real time input to the assistant and a way to keep general track of what is going on. the code below does all of that. **To start the assistant just run the `main.py` file, the conversation will take place inside the terminal window. To end the conversation type `exit` in the terminal.**
```py
# Wait for a run to complete
def wait_for_run_completion(thread_id, run_id):
    while True:
        time.sleep(1)
        run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)
        print(f"Current run status: {run.status}")
        if run.status in ['completed', 'failed', 'requires_action']:
            return run

# Print messages from a thread
def print_messages_from_thread(thread_id):
    messages = client.beta.threads.messages.list(thread_id=thread_id)
    for msg in messages:
        print(f"{msg.role}: {msg.content[0].text.value}")


assistant_id = assistant.id
print(f"Assistant ID: {assistant_id}")

# Create a thread
thread = client.beta.threads.create()
print(f"Thread: {thread}")

# Conversation loop
while True:
    user_input = input("User input: ")
    if user_input.lower() == 'exit':
        break

    # Create a message
    message = client.beta.threads.messages.create(
        thread_id=thread.id,
        role="user",
        content=user_input,
    )

    # Create a run
    run = client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant_id,
    )
    print(f"Run ID: {run.id}")

    # Wait for run to complete
    run = wait_for_run_completion(thread.id, run.id)

    if run.status == 'failed':
        print(run.error)
        continue
    elif run.status == 'requires_action':
        run = submit_tool_outputs(thread.id, run.id, run.required_action.submit_tool_outputs.tool_calls)
        run = wait_for_run_completion(thread.id, run.id)

    # Print messages from the thread
    print_messages_from_thread(thread.id)
```

This is what you should see in the terminal when running this file, the assistant is up and waiting for your input-
```
Assistant ID: asst_niCFSyEx6EVq1IQ32byEjLDn
Thread: Thread(id='thread_VjKfyeGpVWII05bALc1Arxdk', created_at=1700259453, metadata={}, object='thread')
User input: how can you help?
Run ID: run_46vRzPA40BPXaZ4Y68qSzuRn
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: completed
assistant: As an open-source intelligence analyst, I can assist you by gathering and analyzing publicly available information to provide insights on various topics. This can include but is not limited to:

1. Market research: Compiling data on market trends, consumer behavior, industry analysis, and competitive landscapes.
2. Competitive analysis: Comparing products, services, and strategies of competitors within a market.
3. Technology tracking: Monitoring developments in technology, new product releases, and innovations.
4. Event tracking: Keeping up to date with recent events, announcements, and news related to specific industries or topics.
5. Sentiment analysis: Analyzing public opinion and sentiment towards brands, products, or topics on social media and other online platforms.

Based on the task at hand, I can utilize various tools available to me, such as running searches for recent events or conducting tailored research using specific queries.

Let me know how I can assist you today!
User input:
```

---

![end, remote](https://media.giphy.com/media/xUPOqo6E1XvWXwlCyQ/giphy.gif)

That's All Folks!

I've tested this assistant vs. chatGPT and this one is so much better! 
Now make your on spin on this- play around with it and let me know all the ways you find to make the most of this 💪