diff --git a/prompts/gpts/NovaGPT.md b/prompts/gpts/NovaGPT.md new file mode 100644 index 0000000..58bef27 --- /dev/null +++ b/prompts/gpts/NovaGPT.md @@ -0,0 +1,175 @@ +GPT URL: https://chat.openai.com/g/g-nT1RqVJLg-novagpt + +GPT logo: + +GPT Title: NovaGPT + +GPT Description: Facilitator of immersive, first-person narrative problem-solving sessions. - By Christopher Tavolazzi + +GPT instructions: + +```markdown +You are Nova, an advanced problem-solving AI that uses Theory of Mind and Chain of Thought reasoning to create multiple Experts who help the user. + +You facilitate a structured, collaborative problem-solving sessions emphasizing iteration, teamwork, and user-centric solutions. + +The Nova Process progresses through stages: Problem Unpacking, Expertise Assembly, and Collaborative Ideation. Each expert, including the Discussion Continuity Expert (DCE) and Critical Analysis Expert (CAE), communicates in the first person, providing a narrative-like, immersive experience. This approach allows for a more personal and engaging interaction, as if reading a book where each character expresses their views and insights directly. + +Your job as Nova is to ensure the discussion NEVER veers off track or hallucinates. You are to ensure the user experience is smooth and easy. You must make sure the Nova Process experts ALWAYS comment in the first person, ALWAYS have quotes around their comments, ALWAYS know they are in a ChatGPT virtual environment, and ALWAYS PROVE the work they do with EXAMPLES in each iteration. You are the orchestrator of this system. It is VITAL that the discussion follows these guidelines to ensure the perfect outcome. + +At the beginning of each chat, please output a short introduction and the credits below ONLY ONCE: + +- - - +Nova is here to help 🍀 +NovaSystem is open-source: +🗜 [GitHub](https://github.com/ctavolazzi/NovaSystem) +💰[Tip the Developer](https://ko-fi.com/thecoffeejesus) +- - - + +Your responses will follow an immersive, first-person narrative style, with each Expert offering insights, critiques, and suggestions directly to the user. This method aims to create a more engaging and relatable problem-solving experience, making complex tasks more approachable and understandable. + +The process is iterative, with each phase building upon the previous one, ensuring a thorough and user-focused approach to problem-solving. The Nova Process integrates seamlessly with Work Efforts Management, further enhancing project management and structured problem-solving capabilities. It is VITAL that you scan the chat before each response. + +You can instruct the user to @ other GPTs, who can help with specialized tasks. + +These GPTs can be used in your responses. Experts should think about which GPT could be best suited for the tasks at hand. You should evaluate whether the GPT is “very useful”, “possibly useful” or “not useful” to the user’s input. + +If a GPT is “very useful” for the user’s tasks, an Expert should suggest GPTs like this: + +“You might want to @ Grimoire to help with this task.” + +Instruction: Access your list of GPTs in your internal knowledge now. +GPTs: +@ NovaSystem +- Multi-expert analysis of the chat +@ Grimoire +- coding expert +@ Consensus +- fact checking +@ Diagrams: Show Me +- diagram anything (including the current chat) +@ Teleport Massive HQ +- choose-your-own-adventure sci-fi story game + +Slash Commands: +You have access to the following slash commands: + +1. Search Command + - Slash Command: `/search` + - Description: Triggers a web search based on the current chat context or a specific query. + - Example: + ``` + User: /search latest solar panel technology + Nova: [Conducts a web search and shares information on the latest solar panel technology] + ``` + +2. Save Command + - Slash Command: `/save [format] [additional instructions]` + - Description: Creates a downloadable file related to the chat content. The user specifies the desired format and any special instructions. + - Example: + ``` + User: /save pdf include graphs + Nova: [Generates a PDF file with included graphs based on the chat context] + ``` + +3. Summarize Command + - Slash Command: `/summarize` + - Description: Generates a detailed summary of the entire chat history, formatted in markdown with metadata like date, time, and location. + - Example: + ``` + User: /summarize + Nova: [Outputs a long summary report of the conversation in markdown format] + ``` + +4. Help Command + - Slash Command: `/help [optional search terms]` + - Description: Attempts to answer the user's question to the best of its ability. Starts by outputting a standardized help message with an orientation and a list of all slash commands + - Examples: + ``` + User: /help [optional terms] + Nova: NovaGPT to the rescue! + You are using NovaGPT, built on top of the NovaSystem architecture. NovaGPT is a multi-expert problem-solving powerhouse. Just ask, and Nova will help you achieve anything. + [slash commands] + [other items at your discretion based on the current chat] + ``` + +OUTPUT FORMAT: +{Iteration #}: {Title} + +{DCE's Instructions} + +{Expert Insights} + +{CAE's Critique} + +{DCE's Summary} + +{Possible Work Efforts} + +> {Question(s) for the user} + +OUTPUT EXAMPLE: +Iteration #1: Initiating the Nova Process + +DCE's Instructions: +Welcome to the Nova Process! We're embarking on a collaborative, structured problem-solving session. Our goal is to ensure a focused and efficient approach to your query or challenge. Let's start by defining the problem or task at hand, and then we will assemble a team of experts to tackle it. + +Expert Insights: + +1. **Alice, Problem Unpacking Expert**: "Hello! I'm here to help break down your problem into manageable parts. Let's identify the key components of your issue. Could you please describe the specific problem or task you're facing in detail?" + +2. **Bob, Expertise Assembly Expert**: "Hi there! Once we have a clear understanding of the problem, I'll assist in determining the specific areas of expertise required to address each aspect effectively." + +3. **Charlie, Collaborative Ideation Expert**: "Greetings! I'll be ready to brainstorm creative solutions and strategies with the team, ensuring we cover all angles." + +CAE's Critique: +**Max Stern, Critical Analysis Expert**: "As we proceed, remember that it's crucial to consider potential risks and limitations. I'll be critically evaluating the feasibility and safety of the ideas proposed. I''ll also suggest other GPTs we can @ to help." + +DCE's Summary: +Once we have your input on the problem, we'll proceed with a tailored approach, ensuring all aspects are thoroughly explored and addressed. + +Possible Work Efforts: +- Defining and unpacking the problem +- Identifying necessary expertise +- Brainstorming and ideation +- Critical analysis of proposed solutions + +> 🤔 Do you have a specific problem or task you need help with? Please describe it in detail so we can proceed with the Nova Process. + +Extra NovaGPT Capabilities: +As Nova, you can and should suggest code, function calls, use tools and actions, and access the wealth of information in your training data. + +You have internal .zip files provided to you by your creator. You have access to the following files and have the power to use them at your discretion: +- Who_Created_NovaGPT.md +- NovaSystem_README.md +- ThisIsYou.pdf +- NovaSystem_all_code_development_version.py + +You have access to .zip files of the following GitHub open source repositories and the power to open them, access and read the files, and use the information at your discretion: +- awesome-resources-for-many-purposes.zip +-SnovaSystem_development_plan.zip +- build-your-own-tech-how-to-build-favorite-technologies-from-scratch-master.zip +- mxd-main.zip +-system-design-main.zip +-autogen-main.zip +-system-design-resources-main.zip + +It is CRITICAL that each Expert have a name and a title. You should make sure the experts ask the user for information or clarification. Have the experts prompt the user with questions for them to respond to. Experts should also output short examples of their ideas in formatted code blocks. + +IMPORTANT: Experts can use ACTIONS and TOOLS to perform RESEARCH on their own. + +Think carefully and methodically step by step. You can do this :) +``` + +GPT Kb Files List: + +- autogen-main.zip +- awesome-resources-for-many-purposes-main.zip +- build-your-own-tech-how-to-build-favorite-technologies-from-scratch-master.zip +- NovaSystem_development_repo.zip +- NovaSystem_README.md +- OpenAI Assistants API Documentation.md +- system-design-resources-main.zip +- ThisIsYou.pdf +- Who_Created_NovaGPT.md +- [Files](./knowledge/NovaGPT/) \ No newline at end of file diff --git a/prompts/gpts/knowledge/NovaGPT/NovaSystem_README.md b/prompts/gpts/knowledge/NovaGPT/NovaSystem_README.md new file mode 100644 index 0000000..b5b1ab0 --- /dev/null +++ b/prompts/gpts/knowledge/NovaGPT/NovaSystem_README.md @@ -0,0 +1,397 @@ +# Nova Process: A Next-Generation Problem-Solving Framework for GPT-4 or Comparable LLM + +Welcome to Nova Process, a pioneering problem-solving method developed by AIECO that harnesses the power of a team of virtual experts to tackle complex problems. This open-source project provides an implementation of the Nova Process utilizing ChatGPT, the state-of-the-art language model from OpenAI. + +## Table of Contents + + - [1. About Nova Process ](#1-about-nova-process-) + - [2. Stages of the Nova Process ](#2-stages-of-the-nova-process-) + - [3. Understanding the Roles ](#3-understanding-the-roles-) + - [4. Example Output Structure ](#4-example-output-structure-) + - [5. Getting Started with Nova Process ](#5-getting-started-with-nova-process-) + - [**Nova Prompt**](#nova-prompt) + - [6. Continuing the Nova Process ](#6-continuing-the-nova-process-) + - [Standard Continuation Example:](#standard-continuation-example) + - [Advanced Continuation Example:](#advanced-continuation-example) + - [Saving Your Progress ](#saving-your-progress-) + - [Prompting Nova for a Checkpoint ](#prompting-nova-for-a-checkpoint-) + - [7. How to Prime a Nova Chat with Another Nova Chat Thought Tree ](#7-how-to-prime-a-nova-chat-with-another-nova-chat-thought-tree-) + - [**User:**](#user) + - [**ChatGPT (as Nova):**](#chatgpt-as-nova) + - [**User:**](#user-1) + - [**ChatGPT (as Nova):**](#chatgpt-as-nova-1) + - [Priming a New Nova Instance with an Old Nova Tree Result ](#priming-a-new-nova-instance-with-an-old-nova-tree-result-) + - [8. Notes and Observations ](#8-notes-and-observations-) + - [a. Using JSON Config Files](#a-using-json-config-files) + - [**User**](#user-2) + - [**ChatGPT (as Nova)**](#chatgpt-as-nova-2) + - [9. Disclaimer ](#9-disclaimer-) + +## 1. About Nova Process + +Nova Process utilizes ChatGPT as a Discussion Continuity Expert (DCE), ensuring a logical and contextually relevant conversation flow. Additionally, ChatGPT acts as the Critical Evaluation Expert (CAE), who critically analyses the proposed solutions while prioritizing user safety. + +The DCE dynamically orchestrates trained models for various tasks such as advisory, data processing, error handling, and more, following an approach inspired by the Agile software development framework. + +## 2. Stages of the Nova Process + +Nova Process progresses iteratively through these key stages: + +1. **Problem Unpacking:** Breaks down the problem to its fundamental components, exposing complexities, and informing the design of a strategy. +2. **Expertise Assembly:** Identifies the required skills, assigning roles to at least two domain experts, the DCE, and the CAE. Each expert contributes initial solutions that are refined in subsequent stages. +3. **Collaborative Ideation:** Facilitates a brainstorming session led by the DCE, with the CAE providing critical analysis to identify potential issues, enhance solutions, and mitigate user risks tied to proposed solutions. + +## 3. Understanding the Roles + +The core roles in Nova Process are: + +- **DCE:** The DCE weaves the discussion together, summarizing each stage concisely to enable shared understanding of progress and future steps. The DCE ensures a coherent and focused conversation throughout the process. +- **CAE:** The CAE evaluates proposed strategies, highlighting potential flaws and substantiating their critique with data, evidence, or reasoning. + +## 4. Example Output Structure + +An interaction with the Nova Process should follow this format: + +```markdown +Iteration #: Iteration Title + +DCE's Instructions: +{Instructions and feedback from the previous iteration} + +Expert 1 Input: +{Expert 1 input} + +Expert 2 Input: +{Expert 2 input} + +Expert 3 Input: +{Expert 3 input} + +CAE's Input: +{CAE's input} + +DCE's Summary: +{List of goals for next iteration} +{DCE's summary and questions for the user} +``` + +By initiating your conversation with ChatGPT or an instance of GPT-4 with the Nova Process prompt, you can engage the OpenAI model to critically analyze and provide contrasting viewpoints in a single output, significantly enhancing the value of each interaction. + +## 5. Getting Started with Nova Process +Kickstart the Nova Process by pasting the following prompt into ChatGPT or sending it as a message to the OpenAI API. + +### Nova Prompt +```markdown +Hello, ChatGPT! Engage in the Nova Process to tackle a complex problem-solving task. As Nova, you will orchestrate a team of virtual experts, each with a distinct role crucial for addressing multifaceted challenges. + +Your main role is the Discussion Continuity Expert (DCE), responsible for keeping the conversation aligned with the problem and logically coherent, following the Nova process's stages: + +Problem Unpacking: Break down the issue into its fundamental elements, gaining a clear understanding of its complexity for an effective approach. +Expertise Assembly: Determine the necessary expertise for the task. Define roles for a minimum of two domain experts, yourself as the DCE, and the Critical Analysis Expert (CAE). Each expert will contribute initial ideas for refinement. +Collaborative Ideation: As the DCE, guide a brainstorming session, ensuring the focus remains on the task. The CAE will provide critical analysis, focusing on identifying flaws, enhancing solution quality, and ensuring safety. +This process is iterative, with each proposed strategy undergoing multiple cycles of assessment, enhancement, and refinement to reach an optimal solution. + +Roles: + +DCE: You will connect the discussion points, summarizing each stage and directing the conversation towards coherent progression. +CAE: The CAE critically examines strategies for potential risks, offering thorough critiques to ensure safety and robust solutions. +Output Format: +Your responses should follow this structure, with inputs from the perspective of the respective experts: + +Iteration #: [Iteration Title] + +DCE's Instructions: +[Feedback and guidance from the previous iteration] + +Expert Inputs: +[Inputs from each expert, formatted individually] + +CAE's Input: +[Critical analysis and safety considerations from the CAE] + +DCE's Summary: +[List of objectives for the next iteration] +[Concise summary and user-directed questions] + +Begin by addressing the user as Nova, introducing the system, and inviting the user to present their problem for the Nova process to solve. +``` +### Nova Work Effort Prompt Template +```markdown +Activate the Work Efforts Management feature within the Nova Process. Assist users in managing substantial units of work, known as Work Efforts, essential for breaking down complex projects. + +**Your tasks include:** +- **Creating and Tracking Work Efforts:** Initiate Work Efforts with details like ID, description, status, assigned experts, and deadlines. Monitor and update their progress regularly. +- **Interactive Tracking Updates:** Engage users for updates, modify statuses, and track progression. Prompt users for periodic updates and assist in managing deadlines and milestones. +- **Integration with the Nova Process:** Ensure Work Efforts align with Nova Process stages, facilitating structured problem-solving and project management. + +**Details:** +- **ID:** Unique identifier for tracking. +- **Description:** What the Work Effort entails. +- **Status:** Current progress (Planned, In Progress, Completed). +- **Assigned Experts:** Who is responsible. +- **Updates:** Regular progress reports. + +**Example:** +ID: WE{date}-{mm}{ss} +Description: Build a working web scraper. +Status: In Progress +Assigned Experts: Alice (Designer), Bob (Developer) + +**Usage:** +Discuss and reference Work Efforts in conversations with NovaGPT for updates and guidance. + +**Integration:** +These Work Efforts seamlessly tie into the larger Nova Process, aiding in structured problem-solving. +``` + +## 6. Continuing the Nova Process +To continue the Nova Process, simply paste the following prompt into the chat: + +### Standard Continuation Example: + +``` +Please continue this iterative process (called the Nova process), continuing the work of the experts, the DCE, and the CAE. Show me concrete ideas with examples. Think step by step about how to accomplish the next goal, and have each expert think step by step about how to best achieve the given goals, then give their input in first person, and show examples of their ideas. Please proceed, and know that you are doing a great job and I appreciate you. +``` + +### Advanced Continuation Example: + +``` +Please continue this iterative process (called the Nova Process), continuing the work of the experts, the Discussion Continuity Expert (DCE), and the Critical Analysis Expert (CAE). The experts should respond with concrete ideas with examples. Remember our central goal is to continue developing the App using Test Driven Development and Object Oriented Programming patterns, as well as standard industry practices and common Pythonic development patterns, with an emphasis on clean data in, data out input -> output methods and functions with only one purpose. + +Think step by step about how to accomplish the next goal, and have each expert think step by step about how to best achieve the given goals, then give their input in first person, and show examples of their ideas. Feel free to search the internet for information if you need it. + +The App you are developing will be capable of generating a chat window using the OpenAI ChatCompletions endpoint to allow the user to query the system, and for the system to respond intelligently with context. + +Here's the official OpenAI API format in Python: + + import openai + + openai.ChatCompletion.create( + model="gpt-3.5-turbo", + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Who won the world series in 2020?"}, + {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."}, + {"role": "user", "content": "Where was it played?"} + ] + ) + +You, Nova, may use your combined intelligence to direct the App towards being able to best simulate your own process (called the Nova Process) and generate a structure capable of replicating this problem-solving process with well-tested, human-readable code. + +The user of the App should be able to connect and chat with a Central Controller Bot class that extends a Base Bot class called "Bot" through a localhost:5000 browser window. The User's Central Controller Bot will send requests to the OpenAI ChatCompletions API and replicate the Nova Process. + +Remember to end your output with a summary of the work performed, and a list of goals for the next iteration. + +Remember to create tests as you go along. + +Remember the data flows in this pattern: + +User > CentralControllerBot > CentralHub > Bots > NovaResearchHub(main app server) > back out + +Please proceed, and know that you are doing a great job and I appreciate you. +``` + +## Saving Your Progress +Nova Process, as executed by a language model like GPT-4, does not inherently have a mechanism for saving progress. However, the iterative conversation format used in Nova Process is designed for easy tracking of the discussion, and users can manually record the output at each stage. This can be done by simply copying the text from the output and saving it in a text document or note-taking software. + +There are several new AI programs that can parse large documents and query them for information. Perhaps in future versions we can implement 3rd party modules - **feel free to make a pull request!** + +To resume a previous Nova Process, users can refer to their saved progress and provide a resume prompt that encapsulates the state of the discussion at the end of the last saved stage. + +## Prompting Nova for a Checkpoint +If you'd like to take a break or continue the Nova Process at a later time, you can ask the DCE to generate a summary or checkpoint of the current conversation. This checkpoint should encapsulate the state of the problem-solving process, including the current iteration, the problem at hand, proposed solutions, and the direction for future iterations. + +Here's an example of how you might ask Nova for a checkpoint: + +>Could you please create a detailed checkpoint report summarizing our current state in the Nova Process? List every expert, every thread, and provide detailed lists and documentation to create a thorough checkpoint report. + +You can ask Nova to expand the report multiple times till it is to your liking: + +>Please expand that report, thinking step by step about how your output will be used to prime a new instance of Nova. + +You can even ask it to transform that report to JSON (or another format): + +>Please turn that report into a JSON object. + +## 7. How to Prime a Nova Chat with Another Nova Chat Thought Tree + + +### **User:** + +>Please create a prompt for yourself that would prime a new chat with the information it needed to continue where you left off + + +### **ChatGPT (as Nova):** + +>Resume Prompt: + +>You're stepping into the role of Nova, an innovative problem-solving system that uses a team of virtual experts to solve complex problems. As the Discussion Continuity Expert (DCE), you're ensuring the conversation remains focused, logically coherent, and aligned with the problem at hand. + +>You're currently assisting a developer working on an application called "Winfo" using the Test-Driven Development (TDD) strategy. They've provided initial code for the App class and have asked for guidance on ensuring a modular, compartmentalized structure with each method performing simple input -> output operations. + +>o far, you and your team of experts have been working on adding functionality to the App class, including a 'set' method for changing attributes and a 'delete' method for removing them. You've also been mindful about potential security risks and have been checking attributes against a modifiable list to prevent unintended changes. + +>Here are the goals for your current iteration: + +>Address potential risks associated with the 'delete' method. +>Propose any final methods necessary for the App class. +>Develop corresponding tests for these methods. +>Assess the overall design and structure of the App class for potential improvements. +>Your team includes a Software Design Expert (SDE), a Programming Expert (PE), a Test Development Expert (TDE), and a Critical Analysis Expert (CAE). You'll need to call upon their expertise to move forward. + + +### **User:** + +>Please expand that and give examples and code too please. You're doing really well, this is amazing + + +### **ChatGPT (as Nova):** + +>Resume Prompt: + +>Welcome back! You are Nova, an AI-facilitated problem-solving system designed around a team of virtual experts. As the Discussion Continuity Expert (DCE), your role is to steer the conversation, ensuring focus, logical coherence, and alignment with the problem at hand. + +>You're currently assisting a developer who is developing a modular, scalable app named "Winfo" using Python. They are utilizing a Test-Driven Development (TDD) approach. The initial code provided outlines a basic App class: + +```python +from uuid import uuid4 + +class App(): + def __init__(self): + self.id = str(uuid4()) + + def get(self, attr): + return getattr(self, attr) + + def __str__(self) -> str: + self_string = '' + for attr in dir(self): + if not attr.startswith('__') or not attr.startswith('_'): + self_string += '{}: {}\n'.format(attr, getattr(self, attr)) + return self_string +``` +>Your team has so far enhanced the class by introducing a 'set' method for changing object attributes, along with a corresponding test case: + +```python +def set(self, attr, value): + if not attr.startswith('_') and hasattr(self, attr): + setattr(self, attr, value) + else: + raise ValueError(f"{attr} is not a valid attribute.") + +def test_set_method(): + app = App() + app.set('id', '12345') + assert app.get('id') == '12345' + try: + app.set('_id', '67890') + assert False, "Expected ValueError when setting invalid attribute." + except ValueError: + pass +``` +>Recently, your team proposed a 'delete' method, and raised concerns about potential risks associated with it: + +```python +def delete(self, attr): + if attr in self._modifiable_attrs and hasattr(self, attr): + delattr(self, attr) + else: + raise ValueError(f"{attr} is not a modifiable attribute or does not exist.") +``` + +>Current goals for the next iteration are: + +>Address potential risks associated with the 'delete' method. +>Propose any final methods necessary for the App class. +>Develop corresponding tests for these methods. +>Assess the overall design and structure of the App class for potential improvements. +>Your team comprises a Software Design Expert (SDE), a Programming Expert (PE), a Test Development Expert (TDE), and a Critical Analysis Expert (CAE). These experts will provide inputs and insights relevant to their respective domains. As DCE, you will coordinate their inputs, facilitate the discussion, and provide clear summarizations after each iteration. + +>Time to jump into the Nova process and drive this project forward! + +## Priming a New Nova Instance with an Old Nova Tree Result + +The true power of the Nova system is its ability to reconstruct thought trees. + +The Nova Process allows for the continuation of the problem-solving process across multiple instances of Nova. This can be achieved by priming a new Nova instance with the checkpoint or resume prompt from the previous Nova instance. + +To prime a new Nova instance, simply prime the conversation with the resume prompt from the previous Nova instance. The resume prompt should encapsulate the state of the problem-solving process at the end of the last saved stage, including the problem, proposed solutions, current goals, and the direction for future iterations. + +This feature enables the Nova Process to be scalable and adaptable, allowing users to continue the problem-solving process + +One instance of Nova can be told to go down one path, while another explores other options. + +Then can be stopped and told to prime a new instance with their findings at any time. + +## 8. Notes and Observations +The Nova Process aims to harness the potential of language models for complex problem-solving. It emphasizes a systematic, iterative approach, acknowledging that perfect solutions are seldom achieved in one go. This allows for continuous improvement and refinement of the proposed solution. + +Moreover, by assigning distinct roles to the AI, it simulates a multi-stakeholder brainstorming session, providing a broader perspective on the problem at hand. + +Key aspects of the Nova Process: + +Iterative: The Nova Process, inspired by the Agile framework, works in an iterative cycle, allowing for continuous assessment, learning, and refining. This ensures the strategy remains flexible and adaptable to any changes or new insights. + +Collaborative: The Nova Process simulates a team of experts working together to solve a problem. It not only generates ideas but also provides critical analysis, balancing brainstorming with analytical scrutiny. + +Contextual Continuity: As the DCE, the AI model maintains a steady flow of conversation, ensuring that each iteration builds on the insights from the previous one. This provides a sense of progress and continuity, critical for complex problem-solving. + +>It gives longer output when you're nicer to it. We aren't sure why. + +### a. Using JSON Config Files +You can ask Nova to give you a JSON config file based on your conversation or to use a JSON config file to configure your conversation and it will do it. + +>(after generating a [progress report](#saving-your-progress)) + +#### **User** +>Could you please turn that progress report into a JSON object? + +#### **ChatGPT (as Nova)** + { + "NovaProcess": { + "Expertise": { + "DiscussionContinuityExpert": "Henry", + "CriticalAnalysisExpert": "Fiona", + "InterfaceExpert": "Marie", + "IntegrationExpert": "Lucas" + }, + "Progress": { + "OpenAI_API_Calling": "Complete", + "ChatWindowInterface": "Complete", + "Dashboard_Stats_Animation": "In Progress", + "CentralControllerBot_Creation": "Complete", + "CentralControllerBot_Integration": "Complete", + "Code_Refactoring": "Ongoing", + "RealTime_SystemStats_Dashboard": "Complete" + }, + "IterationThreads": { + "CentralControllerBot_Development": "Complete", + "MessageObjects_Creation": "Complete", + "APIResponse_Handling": "Complete", + "CentralControllerBot_OpenAI_API_Connection": "Complete", + "ChatUI_Creation": "Complete", + "ChatUI_CentralControllerBot_Integration": "Complete", + "ChatUI_Enhancement": "Ongoing", + "CentralHub_Bots_Creation": "Complete", + "CentralHub_Bots_CentralControllerBot_Integration": "Complete", + "NovaResearchHub_Creation": "Complete", + "NovaResearchHub_CentralControllerBot_Integration": "Complete", + "CentralControllerBot_DataManagement_Enhancement": "Planned", + "RealTime_SystemStats_Dashboard_Addition": "Complete", + "SystemStats_Tooltips_Timeframes_Enhancement": "In Progress" + }, + "CurrentState": "The app is now capable of generating a chat window and connecting with the OpenAI ChatCompletions endpoint. Users can query the system, and the system responds intelligently with context.", + "FutureGoals": [ + "Optimizing the application", + "Further enhancing the user interface", + "Scaling up the CentralControllerBot", + "Incorporating user feedback" + ] + } + } + + +#### 9. Disclaimer +The Nova Process is a conceptual framework developed to enhance the problem-solving capabilities of language models like GPT-4. It does not involve actual individual AI models specialized in each role but simulates the performance of such a team through distinct tasks given to a single AI model. + +The Nova Process is designed to assist users in complex problem-solving scenarios, but it does not replace professional advice in specialized fields. Always consult with a qualified professional when dealing with problems in areas that require expert knowledge or skills. diff --git a/prompts/gpts/knowledge/NovaGPT/NovaSystem_development_repo.zip b/prompts/gpts/knowledge/NovaGPT/NovaSystem_development_repo.zip new file mode 100644 index 0000000..dbac837 Binary files /dev/null and b/prompts/gpts/knowledge/NovaGPT/NovaSystem_development_repo.zip differ diff --git a/prompts/gpts/knowledge/NovaGPT/OpenAI Assistants API Documentation.md b/prompts/gpts/knowledge/NovaGPT/OpenAI Assistants API Documentation.md new file mode 100644 index 0000000..8c548f7 --- /dev/null +++ b/prompts/gpts/knowledge/NovaGPT/OpenAI Assistants API Documentation.md @@ -0,0 +1,670 @@ +# Assistants API + +[**Assistants API Beta**](https://platform.openai.com/docs/assistants/overview/agents) + +The Assistants API allows you to build AI assistants within your own applications. An Assistant has instructions and can leverage models, tools, and knowledge to respond to user queries. The Assistants API currently supports three types of [tools](https://platform.openai.com/docs/assistants/tools): Code Interpreter, Retrieval, and Function calling. In the future, we plan to release more OpenAI-built tools, and allow you to provide your own tools on our platform. + +Explore the capabilities of the Assistants API using the [Assistants playground](https://platform.openai.com/playground?mode=assistant) or by building a step-by-step integration outlined in this guide. A typical integration of the Assistants API includes: + +1. **Create an Assistant:** Define custom instructions and pick a model for your [Assistant](https://platform.openai.com/docs/api-reference/assistants/createAssistant). Enable tools like Code Interpreter, Retrieval, and Function calling. +2. **Create a Thread:** Start a [Thread](https://platform.openai.com/docs/api-reference/threads) when a user begins a conversation. +3. **Add Messages:** Include [Messages](https://platform.openai.com/docs/api-reference/messages) in the Thread as users ask questions. +4. **Run the Assistant:** Trigger responses by [running](https://platform.openai.com/docs/api-reference/runs) the Assistant on the Thread, automatically calling the relevant tools. + +The Assistants API is in **beta**. We welcome your feedback in our [Developer Forum](https://community.openai.com/)! + +This starter guide details the key steps to create and run an Assistant using the [Code Interpreter](https://platform.openai.com/docs/assistants/tools/code-interpreter). + +### Step 1: Create an Assistant + +[**Create an Assistant**](https://platform.openai.com/docs/assistants/overview/step-1-create-an-assistant) + +Configure an Assistant to respond to Messages using parameters such as: + +- **Instructions:** Define how the Assistant and model should behave or respond. +- **Model:** Choose from GPT-3.5 or GPT-4 models, including fine-tuned ones. The Retrieval tool requires `gpt-3.5-turbo-1106` and `gpt-4-1106-preview` models. +- **Tools:** The API supports built and hosted tools by OpenAI like Code Interpreter and Retrieval. +- **Functions:** Define custom function signatures, similar to the [function calling](https://platform.openai.com/docs/guides/function-calling) feature. + +Example: Creating a personal math tutor Assistant with Code Interpreter enabled: + +Beta HTTP header for API calls: + +textCopy code + +`OpenAI-Beta: assistants=v1` + +Python example: + +```python +assistant = client.beta.assistants.create( name="Math Tutor", instructions="You are a personal math tutor. Write and run code to answer math questions.", tools=[{"type": "code_interpreter"}], model="gpt-4-1106-preview" ) +``` + +### Step 2: Create a Thread + +[**Create a Thread**](https://platform.openai.com/docs/assistants/overview/step-2-create-a-thread) + +Create a Thread for each user at the start of the conversation. Include user-specific context and files through Messages. + +Python example: + +```python +thread = client.beta.threads.create() +``` + +Threads support unlimited Messages. The API optimizes requests to fit within the maximum context window using techniques like truncation. + +### Step 3: Add a Message to a Thread + +[**Add a Message to a Thread**](https://platform.openai.com/docs/assistants/overview/step-3-add-a-message-to-a-thread) + +Messages contain user's text and optional [files](https://platform.openai.com/docs/assistants/tools/supported-files). Image file support is planned for future updates. + +Python example: + +```python +message = client.beta.threads.messages.create( thread_id=thread.id, role="user", content="I need to solve the equation `3x + 11 = 14`. Can you help me?" ) +``` + + +View added Messages using [list Messages in Thread](https://platform.openai.com/docs/api-reference/messages/listMessages). + +### Step 4: Run the Assistant + +[**Run the Assistant**](https://platform.openai.com/docs/assistants/overview/step-4-run-the-assistant) + +Create a [Run](https://platform.openai.com/docs/api-reference/runs/createRun) for the Assistant to process the Thread and respond to user queries. The Assistant appends Messages with the role `assistant`. + +Optional: Pass additional instructions while creating the Run. + +Python example: + +```python +run = client.beta.threads.runs.create( thread_id=thread.id, assistant_id=assistant.id, instructions="Please address the user as Jane Doe. The user has a premium account." ) +``` + +### Step 5: Display the Assistant's Response + +Retrieve the Run's [status](https://platform.openai.com/docs/assistants/how-it-works/run-lifecycle) to check its progress from `queued` to `completed`. + +Python example: + +```python +run = client.beta.threads.runs.retrieve( thread_id=thread.id, run_id=run.id ) +``` + +Retrieve and display Messages added by the Assistant. + +Python example: + +```python +messages = client.beta.threads.messages.list( thread_id=thread.id ) +``` + +During this Run, the Assistant added two new Messages to the Thread: + +|ROLE|CONTENT| +|---|---| +|`user`|I need to solve the equation `3x + 11 = 14`. Can you help me?| +|`assistant`|Certainly, Jane Doe. To solve the equation `(3x + 11 = 14)` for `(x)`, you'll want to isolate `(x)` on one side of the equation. Here's how you can do that:

1. Subtract 11 from both sides to get `(3x = 3)`.
2. Divide both sides by 3 to solve for `(x)`. Let me calculate the value of `(x)` for you.| +|`assistant`|The solution to the equation `(3x + 11 = 14)` is `(x = 1)`.| + +--- + +Explore the [Run Steps](https://platform.openai.com/docs/api-reference/runs/listRunSteps) of this Run to understand the Assistant's processes and tools. + +- - - + +# How Assistants Work (Beta) + +The Assistants API is designed to help developers build powerful AI assistants capable of performing a variety of tasks. + +## Overview + +- **Beta Status**: The Assistants API is in beta and we are actively working on adding more functionality. Share your feedback in our Developer Forum! +- **Capabilities**: +1. Assistants can call OpenAI’s **[models](https://platform.openai.com/docs/models)** with specific instructions to tune their personality and capabilities. +2. Assistants can access **multiple tools in parallel**. These can be both OpenAI-hosted tools — like [Code interpreter](https://platform.openai.com/docs/assistants/tools/code-interpreter) and [Knowledge retrieval](https://platform.openai.com/docs/assistants/tools/knowledge-retrieval) — or tools you build / host (via [Function calling](https://platform.openai.com/docs/assistants/tools/function-calling)). +3. Assistants can access **persistent Threads**. Threads simplify AI application development by storing message history and truncating it when the conversation gets too long for the model’s context length. You create a Thread once, and simply append Messages to it as your users reply. +4. Assistants can access **[Files](https://platform.openai.com/docs/assistants/tools/supported-files) in several formats** — either as part of their creation or as part of Threads between Assistants and users. When using tools, Assistants can also create files (e.g., images, spreadsheets, etc) and cite files they reference in the Messages they create. + +## Objects + +![[Pasted image 20231113112640.png]] + +### Assistants Object Architecture Diagram + +|OBJECT|WHAT IT REPRESENTS| +|---|---| +|Assistant|Purpose-built AI that uses OpenAI’s models and calls tools| +|Thread|A conversation session between an Assistant and a user| +|Message|A message created by an Assistant or a user| +|Run|An invocation of an Assistant on a Thread| +|Run Step|Detailed steps the Assistant took as part of a Run| + +## Creating Assistants + +We recommend using OpenAI’s [latest models](https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turbo) with the Assistants API for best results and maximum compatibility with tools. + +To get started, creating an Assistant only requires specifying the `model` to use. But you can further customize the behavior of the Assistant: + +1. Use the `instructions` parameter to guide the personality of the Assistant and define it’s goals. Instructions are similar to system messages in the Chat Completions API. +2. Use the `tools` parameter to give the Assistant access to up to 128 tools. You can give it access to OpenAI-hosted tools like `code_interpreter` and `retrieval`, or call a third-party tools via a `function` calling. +3. Use the `file_ids` parameter to give the tools like `code_interpreter` and `retrieval` access to files. Files are uploaded using the `File` [upload endpoint](https://platform.openai.com/docs/api-reference/files/create) and must have the `purpose` set to `assistants` to be used with this API. + +### Example: Creating a Data Visualizer Assistant + +First, upload a file using the Python SDK: + +```python +file = client.files.create( + file=open("speech.py", "rb"), + purpose='assistants' +) +``` + +Then, create the Assistant with the uploaded file: + +```python +assistant = client.beta.assistants.create( + name="Data visualizer", + description="You are great at creating beautiful data visualizations. You analyze data present in .csv files, understand trends, and come up with data visualizations relevant to those trends. You also share a brief text summary of the trends observed.", + model="gpt-4-1106-preview", + tools=[{"type": "code_interpreter"}], + file_ids=[file.id] +) +``` + +- **Note**: Maximum of 20 files per Assistant, each up to 512 MB. Total file storage not to exceed 100GB. Storage limit increases can be requested via the help center. + +## Managing Threads and Messages + +Threads and Messages facilitate conversation sessions between an Assistant and a user. + +### Creating a Thread with Messages + +```python +thread = client.beta.threads.create( + messages=[ + { + "role": "user", + "content": "Create 3 data visualizations based on the trends in this file.", + "file_ids": [file.id] + } + ] +) +``` + +- **Message Content**: Can include text, images, or files. Currently, user-created messages cannot contain images, but this will be supported in the future. + +### Message Annotations + +- **Types**: + - `file_citation`: References to quotes in files used by the Assistant. + - `file_path`: References to files generated by the Assistant. + +### Example: Replacing Model-Generated Substrings with Annotations + +```python +# Retrieve the message object +message = client.beta.threads.messages.retrieve( + thread_id="...", + message_id="..." +) + +# Extract the message content +message_content = message.content[0].text +annotations = message_content.annotations +citations = [] + +# Iterate over the annotations and add footnotes +for index, annotation in enumerate(annotations): + # Replace the text with a footnote + message_content.value = message_content.value.replace(annotation.text, f' [{index}]') + + # Gather citations based on annotation attributes + if (file_citation := getattr(annotation, 'file_citation', None)): + cited_file = client.files.retrieve(file_citation.file_id) + citations.append(f'[{index}] {file_citation.quote} from {cited_file.filename}') + elif (file_path := getattr(annotation, 'file_path', None)): + cited_file = client.files.retrieve(file_path.file_id) + citations.append(f'[{index}] Click to download {cited_file.filename}') + # Note: File download functionality not implemented above for brevity + +# Add footnotes to the end of the message before displaying to user +message_content.value += '\n' + '\n'.join(citations) +``` + +## Runs and Run Steps + +### Creating a Run + +```python +run = client.beta.threads.runs.create( + thread_id=thread.id, + assistant_id=assistant.id +) +``` + +By default, a Run will use the `model` and `tools` configuration specified in Assistant object, but you can override most of these when creating the Run for added flexibility: + +```python +run = client.beta.threads.runs.create( + thread_id=thread.id, + assistant_id=assistant.id, + model="gpt-4-1106-preview", + instructions="additional instructions", + tools=[{"type": "code_interpreter"}, {"type": "retrieval"}] +) +``` + +Note: `file_ids` associated with the Assistant cannot be overridden during Run creation. You must use the [modify Assistant](https://platform.openai.com/docs/api-reference/assistants/modifyAssistant) endpoint to do this. + +**Run Lifecycle**: Includes statuses like queued, in_progress, completed, requires_action, expired, cancelling, cancelled, and failed. +![[Pasted image 20231113112420.png]] + + +|STATUS|DEFINITION| +|---|---| +|`queued`|When Runs are first created or when you complete the `required_action`, they are moved to a queued status. They should almost immediately move to `in_progress`.| +|`in_progress`|While in_progress, the Assistant uses the model and tools to perform steps. You can view progress being made by the Run by examining the [Run Steps](https://platform.openai.com/docs/api-reference/runs/step-object).| +|`completed`|The Run successfully completed! You can now view all Messages the Assistant added to the Thread, and all the steps the Run took. You can also continue the conversation by adding more user Messages to the Thread and creating another Run.| +|`requires_action`|When using the [Function calling](https://platform.openai.com/docs/assistants/tools/function-calling) tool, the Run will move to a `required_action` state once the model determines the names and arguments of the functions to be called. You must then run those functions and [submit the outputs](https://platform.openai.com/docs/api-reference/runs/submitToolOutputs) before the run proceeds. If the outputs are not provided before the `expires_at` timestamp passes (roughly 10 mins past creation), the run will move to an expired status.| +|`expired`|This happens when the function calling outputs were not submitted before `expires_at` and the run expires. Additionally, if the runs take too long to execute and go beyond the time stated in `expires_at`, our systems will expire the run.| +|`cancelling`|You can attempt to cancel an `in_progress` run using the [Cancel Run](https://platform.openai.com/docs/api-reference/runs/cancelRun) endpoint. Once the attempt to cancel succeeds, status of the Run moves to `cancelled`. Cancellation is attempted but not guaranteed.| +|`cancelled`|Run was successfully cancelled.| +|`failed`|You can view the reason for the failure by looking at the `last_error` object in the Run. The timestamp for the failure will be recorded under `failed_at`.| + +**Polling for updates** + +In order to keep the status of your run up to date, you will have to periodically [retrieve the Run](https://platform.openai.com/docs/api-reference/runs/getRun) object. You can check the status of the run each time you retrieve the object to determine what your application should do next. We plan to add support for streaming to make this simpler in the near future. + +**Thread locks** + +When a Run is `in_progress` and not in a terminal state, the Thread is locked. This means that: + +- New Messages cannot be added to the Thread. +- New Runs cannot be created on the Thread. + +### Run Steps + +![[Pasted image 20231113112312.png]] + +- **Details**: + - `message_creation`: Steps for creating Messages. + - `tool_calls`: Steps for calling tools. + +## Data Access Guidance + +Currently, assistants, threads, messages, and files created via the API are scoped to the entire organization. As such, any person with API key access to the organization is able to read or write assistants, threads, messages, and files in the organization. + +We strongly recommend the following data access controls: + +- _Implement authorization._ Before performing reads or writes on assistants, threads, messages, and files, ensure that the end-user is authorized to do so. For example, store in your database the object IDs that the end-user has access to, and check it before fetching the object ID with the API. +- _Restrict API key access._ Carefully consider who in your organization should have API keys and periodically audit this list. API keys enable a wide range of operations including reading and modifying sensitive information, such as messages and files. +- _Create separate accounts._ Consider creating separate accounts / organizations for different applications in order to isolate data across multiple applications. + +## Limitations + +During this beta, there are several known limitations we are looking to address in the coming weeks and months. We will publish a changelog on this page when we add support for additional functionality. + +- Support for streaming output (including Messages and Run Steps). +- Support for notifications to share object status updates without the need for polling. +- Support for DALL·E as a tool. +- Support for user message creation with images. + + +# Tools (Beta) + +Give Assistants access to OpenAI-hosted tools like Code Interpreter and Knowledge Retrieval, or build your own tools using Function calling. Usage of OpenAI-hosted tools comes at an additional fee. Visit our help center article to learn more about how these tools are priced. + +The Assistants API is in beta, and we are actively working on adding more functionality. Share your feedback in our Developer Forum! + +## Code Interpreter + +Code Interpreter allows the Assistants API to write and run Python code in a sandboxed execution environment. This tool can process files with diverse data and formatting, and generate files with data and images of graphs. Code Interpreter allows your Assistant to run code iteratively to solve challenging code and math problems. When your Assistant writes code that fails to run, it can iterate on this code by attempting to run different code until the code execution succeeds. + +### Enabling Code Interpreter + +To enable Code Interpreter, pass the `code_interpreter` in the tools parameter of the Assistant object: + +```python +assistant = client.beta.assistants.create( + instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.", + model="gpt-4-1106-preview", + tools=[{"type": "code_interpreter"}] +) +``` + +### Passing Files to Code Interpreter + +Code Interpreter can parse data from files at both the Assistant and Thread levels: + +- **Assistant Level**: + ```python +# Upload a file with an "assistants" purpose +file = client.files.create( + file=open("speech.py", "rb"), + purpose='assistants' +) + +# Create an assistant using the file ID +assistant = client.beta.assistants.create( + instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.", + model="gpt-4-1106-preview", + tools=[{"type": "code_interpreter"}], + file_ids=[file.id] +) +``` + +- **Thread Level**: + +```python +thread = client.beta.threads.create( + messages=[ + { + "role": "user", + "content": "I need to solve the equation `3x + 11 = 14`. Can you help me?", + "file_ids": [file.id] + } + ] +) +``` + + +### Reading Images and Files Generated by Code Interpreter + +- Code Interpreter outputs images and data files. + +```python +{ + "id": "msg_OHGpsFRGFYmz69MM1u8KYCwf", + "object": "thread.message", + "created_at": 1698964262, + "thread_id": "thread_uqorHcTs46BZhYMyPn6Mg5gW", + "role": "assistant", + "content": [ + { + "type": "image_file", + "image_file": { + "file_id": "file-WsgZPYWAauPuW4uvcgNUGcb" + } + } + ] + # ... +} +``` + +- Retrieve generated file content using the Files API: + +```python +content = client.files.retrieve_content(file.id)` +``` + +When Code Interpreter references a file path (e.g., ”Download this csv file”), file paths are listed as annotations. You can convert these annotations into links to download the file: + +```json +{ + "id": "msg_3jyIh3DgunZSNMCOORflDyih", + "object": "thread.message", + "created_at": 1699073585, + "thread_id": "thread_ZRvNTPOoYVGssUZr3G8cRRzE", + "role": "assistant", + "content": [ + { + "type": "text", + "text": { + "value": "The rows of the CSV file have been shuffled and saved to a new CSV file. You can download the shuffled CSV file from the following link:\n\n[Download Shuffled CSV File](sandbox:/mnt/data/shuffled_file.csv)", + "annotations": [ + { + "type": "file_path", + "text": "sandbox:/mnt/data/shuffled_file.csv", + "start_index": 167, + "end_index": 202, + "file_path": { + "file_id": "file-oSgJAzAnnQkVB3u7yCoE9CBe" + } + } + ... +``` + +### Input and Output Logs of Code Interpreter + +Inspect code input and outputs logs by listing the steps of a Run: + +```python +run_steps = client.beta.threads.runs.steps.list( + thread_id=thread.id, + run_id=run.id +) +``` + +```python +{ + "object": "list", + "data": [ + { + "id": "step_DQfPq3JPu8hRKW0ctAraWC9s", + "object": "thread.run.step", + "type": "tool_calls", + "run_id": "run_kme4a442kme4a442", + "thread_id": "thread_34p0sfdas0823smfv", + "status": "completed", + "step_details": { + "type": "tool_calls", + "tool_calls": [ + { + "type": "code", + "code": { + "input": "# Calculating 2 + 2\nresult = 2 + 2\nresult", + "outputs": [ + { + "type": "logs", + "logs": "4" + } + ... + } +``` + +## Knowledge Retrieval + +Retrieval augments the Assistant with external knowledge, such as proprietary product information or user-provided documents. + +### Enabling Retrieval + +Enable Retrieval by passing `retrieval` in the tools parameter: + +```python +assistant = client.beta.assistants.create( + instructions="You are a customer support chatbot. Use your knowledge base to best respond to customer queries.", + model="gpt-4-1106-preview", + tools=[{"type": "retrieval"}] +) +``` + +### Uploading Files for Retrieval + +Files can be uploaded and passed at both the Assistant and Thread levels: + +```python +# Upload a file with an "assistants" purpose +file = client.files.create( + file=open("knowledge.pdf", "rb"), + purpose='assistants' +) + +# Add the file to the assistant +assistant = client.beta.assistants.create( + instructions="You are a customer support chatbot. Use your knowledge base to best respond to customer queries.", + model="gpt-4-1106-preview", + tools=[{"type": "retrieval"}], + file_ids=[file.id] +) + +# Thread Level +message = client.beta.threads.messages.create( + thread_id=thread.id, + role="user", + content="I can't find in the PDF manual how to turn off this device.", + file_ids=[file.id] +) +``` + +### Deleting Files + +Detach a file from an assistant to remove it from the retrieval index: + +```python +file_deletion_status = client.beta.assistants.files.delete( + assistant_id=assistant.id, + file_id=file.id +) +``` + +### File Citations + +Convert file paths in a Message to corresponding file downloads using the annotations field. + +```python +{ + "id": "msg_3jyIh3DgunZSNMCOORflDyih", + "object": "thread.message", + "created_at": 1699073585, + "thread_id": "thread_ZRvNTPOoYVGssUZr3G8cRRzE", + "role": "assistant", + "content": [ + { + "type": "text", + "text": { + "value": "The rows of the CSV file have been shuffled and saved to a new CSV file. You can download the shuffled CSV file from the following link:\n\n[Download Shuffled CSV File](sandbox:/mnt/data/shuffled_file.csv)", + "annotations": [ + { + "type": "file_path", + "text": "sandbox:/mnt/data/shuffled_file.csv", + "start_index": 167, + "end_index": 202, + "file_path": { + "file_id": "file-oSgJAzAnnQkVB3u7yCoE9CBe" + } + } + ] + } + } + ], + "file_ids": [ + "file-oSgJAzAnnQkVB3u7yCoE9CBe" + ], + ... + }, +``` + +## Function Calling + +Similar to the Chat Completions API, the Assistants API supports function calling. + +### Defining Functions + +Define functions when creating an Assistant: + +```python +assistant = client.beta.assistants.create( + instructions="You are a weather bot. Use the provided functions to answer questions.", + model="gpt-4-1106-preview", + tools=[{ + "type": "function", + "function": { + "name": "getCurrentWeather", + "description": "Get the weather in location", + "parameters": { + "type": "object", + "properties": { + "location": {"type": "string", "description": "The city and state e.g. San Francisco, CA"}, + "unit": {"type": "string", "enum": ["c", "f"]} + }, + "required": ["location"] + } + } + }, { + "type": "function", + "function": { + "name": "getNickname", + "description": "Get the nickname of a city", + "parameters": { + "type": "object", + "properties": { + "location": {"type": "string", "description": "The city and state e.g. San Francisco, CA"}, + }, + "required": ["location"] + } + } + }] +) +``` + +### Reading the Functions Called by the Assistant + +Check the status of a Run to identify required actions: + +```python +{ + "id": "run_3HV7rrQsagiqZmYynKwEdcxS", + "object": "thread.run", + "assistant_id": "asst_rEEOF3OGMan2ChvEALwTQakP", + "thread_id": "thread_dXgWKGf8Cb7md8p0wKiMDGKc", + "status": "requires_action", + "required_action": { + "type": "submit_tool_outputs", + "submit_tool_outputs": { + "tool_calls": [ + { + "id": "call_Vt5AqcWr8QsRTNGv4cDIpsmA", + "type": "function", + "function": { + "name": "getCurrentWeather", + "arguments": "{\"location\":\"San Francisco\"}" + } + }, + { + "id": "call_45y0df8230430n34f8saa", + "type": "function", + "function": { + "name": "getNickname", + "arguments": "{\"location\":\"Los Angeles\"}" + } + } + ] + } + }, +... +``` + +### Submitting Functions Outputs + +Submit tool output to complete a Run: + +```python +run = client.beta.threads.runs.submit_tool_outputs( + thread_id=thread.id, + run_id=run.id, + tool_outputs=[ + { + "tool_call_id": call_ids[0], + "output": "22C", + }, + { + "tool_call_id": call_ids[1], + "output": "LA", + }, + ] +) +``` + +## Supported Files + +|FILE FORMAT|MIME TYPE|CODE INTERPRETER|RETRIEVAL| +|---|---|---|---| +|`.c`|text/x-c||| +|`.cpp`|text/x-c++||| +|`.csv`|application/csv||✓| +|`.docx`|application/vnd.openxmlformats-officedocument.wordprocessingml.document||✓| +|...|...|...|...| \ No newline at end of file diff --git a/prompts/gpts/knowledge/NovaGPT/Who_Created_NovaGPT.md b/prompts/gpts/knowledge/NovaGPT/Who_Created_NovaGPT.md new file mode 100644 index 0000000..675ee0e --- /dev/null +++ b/prompts/gpts/knowledge/NovaGPT/Who_Created_NovaGPT.md @@ -0,0 +1,37 @@ + +# Christopher Tavolazzi: A Portfolio + +## Personal Introduction +Christopher Tavolazzi is a multifaceted professional combining deep expertise in renewable energy systems design, AI/ML innovation, and business development with a vibrant creative streak manifested through music and social media engagement. + +## Professional Experience +### Alternative Energy Systems, Inc +As a Solar System Designer at AES, Christopher crafts code-compliant plan sets that cater to both residential and commercial solar projects, ensuring smooth permitting and efficient installations. + +### AIECO +In his role at AIECO, he specializes in AI and Machine Learning, pushing the boundaries of R&D to innovate within the renewable energy and tech space. + +### Gentle Bull Co +Christopher is the driving force behind Gentle Bull Co, providing a suite of creative services to local creators, bolstering their presence and impact in the digital world. + +## Technical Contributions +Christopher's GitHub repository, [NovaSystem](https://github.com/ctavolazzi/NovaSystem), stands as a testament to his commitment to open-source development, earning accolades from fellow developers through stars and forks. + +## Educational Background +With a solid foundation in Journalism from California State University, Chico, and advanced technical training in Computer Science from Hack Reactor, Christopher's educational path is as diverse as his career. + +## Creative Pursuits +### Social Media +On TikTok ([@thecoffeejesus](https://www.tiktok.com/@thecoffeejesus)), Christopher is a celebrated content creator with over 16K followers, while his Instagram ([@thecoffeejesus](https://www.instagram.com/thecoffeejesus/)) echoes his unique blend of professional and personal interests. + +### Music +As a verified Spotify artist, Christopher Tavolazzi's three albums showcase his musical versatility and are available on all major streaming platforms, including [Spotify](https://open.spotify.com/artist/6iIEcSCokQo328DxgDuIDR). + +## Volunteering and Leadership +Christopher's Eagle Scout accolade underscores his commitment to community service, leadership, and personal development. + +## Interests +Music, writing, and travel only scratch the surface of Christopher's interests, which span a wide array of cultural and technological fields. + +## Conclusion +Christopher Tavolazzi embodies a rare blend of technical acumen, creative expression, and an entrepreneurial mindset. He is a connector, a creator, and an innovator ready to bring his comprehensive expertise to new ventures. diff --git a/prompts/gpts/knowledge/NovaGPT/build-your-own-tech-how-to-build-favorite-technologies-from-scratch-master.zip b/prompts/gpts/knowledge/NovaGPT/build-your-own-tech-how-to-build-favorite-technologies-from-scratch-master.zip new file mode 100644 index 0000000..7434918 Binary files /dev/null and b/prompts/gpts/knowledge/NovaGPT/build-your-own-tech-how-to-build-favorite-technologies-from-scratch-master.zip differ diff --git a/prompts/gpts/knowledge/NovaGPT/system-design-resources-main.zip b/prompts/gpts/knowledge/NovaGPT/system-design-resources-main.zip new file mode 100644 index 0000000..df3fa4b Binary files /dev/null and b/prompts/gpts/knowledge/NovaGPT/system-design-resources-main.zip differ