# Welcome to Cortex Customizing AI copilots for your specific use cases ## Overview **Cortex** is a powerful AI application development platform that allows anyone to create customized AI assistants for themselves or their users. Cortex is built with three design principles in mind: 1. **Personalize**: Create custom AI assistants tailored to each team's unique needs. 2. **Streamline**: Provide a robust environment ready for immediate deployment and scalable growth. 3. **Safeguard**: Maintain an unwavering commitment to data privacy. If you are a non-developer, look into [Copilot](/fundamentals/copilot). If you are a developer, look into [Callable](/fundamentals/callable). ## Get Started We've put together some helpful guides for you to get setup with our product quickly and easily. {% content-ref url="/pages/B4JPZCz94oNC1kNGnfXf" %} [Making your first Copilot](/product-guides/making-your-first-copilot) {% endcontent-ref %} {% content-ref url="/pages/3rXYGale4wcCXeKq8BMZ" %} [Making your first Callable](/product-guides/making-your-first-callable) {% endcontent-ref %} ## Quick links {% content-ref url="/pages/21HxFlQyzDYdwcypgfPI" %} [Understanding Cortex Architecture](/overview/understanding-cortex-architecture) {% endcontent-ref %} {% content-ref url="/pages/YEJtHvOajezWcGSn60H2" %} [Callable](/fundamentals/callable) {% endcontent-ref %} # Understanding Cortex Architecture ## How Cortex work **Cortex** can be seen as having three layers * **Callable:** The infrastructure that handles all LLM-based workflows. It follows serverless function architecture (like AWS Lambda) that enables maximum scalability * **Knowledge:** Managed vector database for fast information retrieval and near real-time syncing * **Client Interface** * **Copilot:** is a managed UI that enables end-users to conveniently interact with AI applications * **API:** API and SDK clients are provided to support developers who wish to directly interact with their callables to power their own products

### A Basic Workflow When the end user interacts with a **Copilot**, a few things happen in the background: 1. Cortex Copilot client compiles users' input into a standard format defined by its UI standard protocol and includes session history. Since Callable is designed to be stateless and serverless, the copilot server will be responsible to store the history. 2. The Copilot client sends an API request to a specific Callable 3. The Callable is triggered and performs its predefined programming. 1. The Callable interacts with Knowledge to retrieve relevant information 2. The Callable sends requests to the language model services 4. The Callable returns a response in a predefined format to Copilot, and Copilot displays the messages to users. # Making your first Copilot Copilots are UI-based AI assistants that are designed for **non-developers** to create their own customizable AI assistants. This tutorial guides you through the process! ## 1. Create a knowledge One of the powerful features of Cortex is to let AI interact with your own data. Knowledge is where you store your data. Head to the knowledge tab here and create a knowledge

Cortex supports multiple upload options. You can directly upload your pdf, or Word doc, give the URLs of a particular website or connect with third-party applications like Notion and Slack, and we will sync up the knowledge automatically.

If you want to learn more about how knowledge works. Go to [Knowledge](/fundamentals/knowledge) Navigate through the rest of the Knowledge setup process, and you will have your first knowledge ready!

### General Setting and Permissions Give your copilot a name and a clear description, and configure the access levels of your copilots

* **Public:** your copilot will be available to anyone on the internet with the copilot link to use. It might also show up on the Discover page * **Private:** your copilot is only visible to you and the people you invited * **Unlisted:** your copilot will be available to anyone on the internet with the copilot link to use. It won't show up on the Discover page or search engines ### Configure UI & Callable #### Select UI Choose which type of UI you'd like your copilots to have. Let's choose Chat UI.

#### Configure Callable Callable is what's powering the Copilots UI. We have a list of pre-built Callable for you to choose from. Pick the one that best fits your use case. If you or your organization have built your own Callable, it will also show up here for you to choose.

select latest version to receive continuous updates ![](https://3035252822-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeiBCAl6qTuG0sZpeXLxC%2Fuploads%2Fa5tYimVLbBHRggJUq97E%2Fimage.png?alt=media\&token=3857e39a-499a-4da0-81d7-bd1a3f4711c5) select my-notion-workspace that we've just created earlier.![](https://3035252822-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeiBCAl6qTuG0sZpeXLxC%2Fuploads%2FnZlxvuFh1OWaZMRmcNoR%2Fimage.png?alt=media\&token=cd3b5921-c0db-42ab-bb9c-faa20b19308c) ### Give examples Give a few examples of how you could use your copilot. This will help your users to understand what your assistants are capable of. For example, for a chat copilot about Notion QA, you can put: "Where is the PRD for the product landing page?"

After clicking + Create Copilot button, your copilot will be available for you to use! You can share this copilot via the URL. # Making your first Callable {% hint style="info" %} Callable is currently in private preview, only selected developers and customers have access to Callable Builder. If you'd like to submit a request please contact ! {% endhint %} Callable is the serverless function that powers each copilot, or any of your AI workflows. Let's build a Callable today that helps recommend movies to watch! ## 1. Create a knowledge One of the powerful features of Cortex is to let AI interact with your own data. Knowledge is where you store your data. Head to the knowledge tab here and create a knowledge

Cortex supports multiple upload options. Let's use Web as our options. Enter the Knowledge name and description and go to the the next step

Enter the url of Rotten Tomateo: . Follow the rest of the set up and your knowledge should be ready to go!

{% hint style="info" %} Give the knowledge upload process a few minutes to fully sync up. You can continue to the next step, the sync up process will continue to run in the background. {% endhint %} ### 2. Create Callable Navigate to Callable Builder and create a callable. Enter the name, description, and set the visibility. We will use "Chat" callable template, which is configured to work with Chat copilot.

Go to the RETRIEVALS block, and select rotten-tomateo as your knowledge. You could select multiple knowledge if you have more information.

You are almost there! Now the last thing to edit would be the prompt that passed into the language model. Let's modify the prompt in the language model block called OUTPUT\_STREAM to this: ```atom You are an expert of movies. Please answer this following question: {{EXTRACT_QUESTION}}, base on following content: {{RETRIEVALS_RESULT}} Please answer the questions with the best of your knowledge. If not, please ask more questions for more information and recommend with some suggestions based on common knowledge. You can make up an answer if you really cannot answer the question. let's begin! ``` Let's also set the Max Tokens to around 2000.

### 3. Test your Callable We've configured our Callable. But how do we know if it will work well? Let's create some test datasets. Go to the Datasets tab and go into ChatDataset.

You can write a few new test cases like this:

Now you are good to run tests! Go back to Design tab and click Run TestCases. Results from each block will be displayed below each block. We can go to the final OUTPUT block to check if the final results look good.

### 4. Deploy! When you feel confident about your Callable's results, hit Deploy on the right top corner. The API for running this callable will be instantly generated, and now can integrate this into your product!

{% hint style="info" %} Remember to always run TestCases before hitting Deploy. After editing your Callable, If you don't run TestCases, Deploy won't freeze your edits into the next version. If you see that the version number hasn't incremented after Deploy, that means there is no new changes being added in production. Try run TestCases and then Deploy. {% endhint %} ### 5. Running it with a Copilot (optional) You could directly consume the Callable API from your project, or you can connect a copilot to this callable and start chatting with it immediately. Create a new Copilot and configure it as such to connect to the callable.

Congratulations! Now you should be able to directly chat with your movie recommendation assistant.

# Copilot ### Chat UI Chat UI is excellent for general purposed QA. It's a conventional chatbot interface similar to ChatGPT

#### Examples By default, Chat will have example questions you can ask the chatbot. Click any example to try it out

#### Session History Your chat session will be saved and available for access anytime on the left navigation bar. You can create a new conversation by clicking the + New Conversation button. Notice that context-aware conversation is only available if the Callable developer incorporates history in the Callable. All Callables created by Cortex Community will have history enabled. ### Text Generation UI Text generation UI is excellent for back-and-forth document editing. It resembles a rich text editor with AI helping you rewrite and generate paragraphs.

#### Editing Field This is the main editing field. You could manually edit paragraphs inside, or ask AI to write for you, and the generated paragraphs will show up inside as well.

#### Instruct AI to write Use the instruction box on the right-hand side to tell AI what to write. You could ask: "write an email to my customer explaining how our pricing plan works." And click generate ![](https://3035252822-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeiBCAl6qTuG0sZpeXLxC%2Fuploads%2FxiYYpnVu8fl3i5f1Rp9T%2Fimage.png?alt=media\&token=c6a78b05-2c81-4568-b863-ca1a1fe1b3cf) #### Instruct AI to rephrase To change a specific portion of your paragraphs, highlight the part you'd like to modify, write in the instruction box on how you'd like to modify it, and click Rephrase. This will replace your old highlighted texts with newly generated paragraphs.

Don't worry about inconsistency, the AI is context-aware, so it knows what're the paragraphs before and after the highlighted texts, and adapts the generated response accordingly. ### Save draft Click the save button at the second left button corner. Saved edits will show up on the left navigation bar. You could click any saved edits to resume editing a previous version.

### Search UI (Coming Soon) Search UI is excellent for finding relevant information from your unstructured documents. It resembles a search engine and includes a short summary of the information you are looking for

# Knowledge ### Overview Knowledge is our managed vector database which allows our users and developers to seamlessly interact with their large amount of data. Our knowledge is designed to be easy to use, with several built-in data integration pipeline that allows users to sync up with their data warehouse dynamically. ### Structure Each Knowledge is considered to be an independent data source. You would want to create different Knowledges for different types of data sources (Notion vs. SQL DB) or exert separate access control policies. There is another division within each Knowledge, called Documents. Knowledge consists of a collection of Documents. You could use documents to insert the same type of data but different contents (different pages in the same Notion workspace). ### Self Managed For the simplest upload options, we allow users to directly upload files from their computers in various formats, such as pdf, docx, and txt. Additionally, developers can also choose to upload and update their knowledge using our [SDK](https://github.com/trycortex-ai). ### Web We provide a built-in HTTP web crawler that will recursively go through most links from the root URL. Just provide the root URL and we will automatically start the crawl. More on its behavior: * We will try to get the site map from the root url, and import the first 100 urls. You can remove the ones you don't want. * we only index first 200k characters of each page. * it works great if your webpage is server-side rendered, but not so great if it's a SPA, we are working on it. ### Notion The Notion integration allows users to seamlessly connect their Notion workspace. By signing in through your Notion account, and selecting the workspaces you want to connect, we will automatically sync up your selected Notion pages. This Knowledge is fully-managed, meaning that any changes from Notion will be updated dynamically to the Knowledge ### Slack Slack integration allows users to connect their Slack message history to Knowledge. It's also a fully managed service like Notion's integration. # Callable {% hint style="info" %} Callable is currently in private preview, only selected developers and customers have access to Callable Builder. If you'd like to submit a request please contact ! {% endhint %} Seems like you don't have access to this page yet. Please contact !

# Getting set up Setting up your team account, available to Enterprise plan.

Step 1: Creating your organization

1. "+ Create Team" on the top navigation bar 2. Name your organization and confirm

Step 2: Inviting your team

1. Go to "Team Management" from the profile icon 2. Go to "Members" 3. Enter the emails of your teammates. By default, all newly joined teammates are User. You can come back later to change their Permission level later.

Step 3: Making your first Copilot

Follow the guide here: [Making your first Copilot](/product-guides/making-your-first-copilot)

# Setting permissions ## Permission levels There are 4 types of permission levels in Cortex.

Role	Capabilities
User	Can only use knowledge, and callable
Builder	Can view, update, create knowledge, callable
Admin	Has all privilages of Builder, and able to set permissions and billing
Owner	Has all privilages of Admin, and cannot be removed

# Blocks {% content-ref url="/pages/2pn1o1NHZvZvFPCC0XrQ" %} [Models](/callable/blocks/models) {% endcontent-ref %} {% content-ref url="/pages/hCuweHimpmK7v9wzXgMd" %} [Data](/callable/blocks/data) {% endcontent-ref %} {% content-ref url="/pages/yJbjhWNJ8VjFA4RKUECE" %} [Tools](/callable/blocks/tools) {% endcontent-ref %} {% content-ref url="/pages/ooQtvWlWsv1l2zzMKs5r" %} [Control](/callable/blocks/control) {% endcontent-ref %} # Models {% content-ref url="/pages/IeNfanufdCdIGZpRfnmU" %} [Language Model](/callable/blocks/models/language-model) {% endcontent-ref %} {% content-ref url="/pages/qrUDjrGkkFHIqsnxQ8M7" %} [Language Model With Code](/callable/blocks/models/language-model-with-code) {% endcontent-ref %} # Language Model The Model Block accepts a specified prompt string and returns a Language Model completion as the result.

**Parameters:** * **Prompt:** Enter your prompt to send to the configured model * **Config:** Provides options for the type of LLM model and the temperature {% hint style="info" %} For the final model block in your callable, it must be named OUTPUT\_STREAM to stream the chat results in your copilot. {% endhint %} **Using Advanced Model Blocks:** {% content-ref url="/pages/ky1043l79csEEB89gZPR" %} [Utilizing Model Examples to Convert Text to JSON](/callable/use-cases/utilizing-model-examples-to-convert-text-to-json) {% endcontent-ref %} # Language Model With Code Sends a prompt and array of functions following the function calling parameter of OpenAI.

**Parameters:** * **Instructions:** Enter prompt to be sent to the model * **Code for Memory:** Input the message history * **Code for Functions:** Array of functions to be sent to OpenAI {% embed url="" %} # Data {% content-ref url="/pages/xpnWp7w4cQTPSA6neVOy" %} [Dataset Loader](/callable/blocks/data/dataset-loader) {% endcontent-ref %} # Dataset Loader ## Dataset Loader Loads Data from the Dataset tab.

**Parameters**: * **Select Data:** Choose an existing dataset from your dataset # Tools {% content-ref url="/pages/GdsU9JU6yF8qwkmeEUQB" %} [Knowledge Search](/callable/blocks/tools/knowledge-search) {% endcontent-ref %} {% content-ref url="/pages/ymwztqxaQI3wZfD676Us" %} [Google Search](/callable/blocks/tools/google-search) {% endcontent-ref %} {% content-ref url="/pages/jmsXAcw21eo6ro2IZKGQ" %} [Curl Request](/callable/blocks/tools/curl-request) {% endcontent-ref %} {% content-ref url="/pages/HHW1BAtOKqSimIiICNFh" %} [Web Page Crawler](/callable/blocks/tools/web-page-crawler) {% endcontent-ref %} # Knowledge Search Search blocks allow Callables to make queries to uploaded Knowledges.

Search Blocks consist of the following fields: * **Query:** Provide the desired prompt to look for inside your knowledges * **Knowledge:** Add and select as many knowledges that you have created. Allows for specific include or exclude tags to better refine your retrieval. **Using Knowledge Block for Retrieval:** {% content-ref url="/pages/6If73mSRMTBP6L5Cnsdg" %} [Retrievals from Knowledge Search Blocks](/callable/use-cases/retrievals-from-knowledge-search-blocks) {% endcontent-ref %} # Google Search Find the most relevant links based on the Query through a google search

**Parameters:** * **Number of Results:** Specifies how many organic results will be returned * **Query:** Specify the question to search on google. Return: {% embed url="" %} # Curl Request Send Curl Requests with the Curl Request block

**Parameters:** * **URL:** The url you are sending the curl request to * **Headers:** Provide the header fields as a javascript object in the return * **Body:** Provide a JSON string with the body parameters you want send. # Web Page Crawler Goes to a specified URL and retrieves the HTML from the page.

**Parameters:** * **URL:** The URL that you want to get HTML data from * **CSS Selector:** Provide an HTML Element () to search the contents for on the specified website. Each result will return the html, text, width, height, top, left, and attributes of the each element that matches the selector. # Control {% content-ref url="/pages/Otfak2aubqrLI1KHHqyE" %} [Code](/callable/blocks/control/code) {% endcontent-ref %} {% content-ref url="/pages/fbBEu5NFQVdtNpBVwzI6" %} [Loop Until](/callable/blocks/control/loop-until) {% endcontent-ref %} {% content-ref url="/pages/6A89GYMDNj6WBzmLIpkD" %} [Map Reduce](/callable/blocks/control/map-reduce) {% endcontent-ref %} # Code Code blocks allow for users to execute JavaScript code in a Callable

The env variable passed into the function allows for referencing previous block outputs inside the Code Block. It uses the syntax `env.state.BLOCK_NAME` to reference a block by its name. In the example above, the block name for the code block would be `CODE_1`. User's can name blocks anything as long as it is unique inside the Callable. # Loop Until Executes code between the start and end of the loop

# Map Reduce Map over an array and executes a sequence of blocks in parallel.

**Parameters:** * **From:** Reference of a block name that outputs an array * **Repeat:** Integer value that specifies the amount of time to repeat the execution of blocks inside the loop # Use Cases {% content-ref url="/pages/v5Lv51Lju9jsk6VcpHWK" %} [Building a Company Help Desk](/callable/use-cases/building-a-company-help-desk) {% endcontent-ref %} {% content-ref url="/pages/DaUjFXIexOEk2BXCQhBg" %} [Creating a Social Media Manager Chatbot](/callable/use-cases/creating-a-social-media-manager-chatbot) {% endcontent-ref %} {% content-ref url="/pages/ky1043l79csEEB89gZPR" %} [Utilizing Model Examples to Convert Text to JSON](/callable/use-cases/utilizing-model-examples-to-convert-text-to-json) {% endcontent-ref %} {% content-ref url="/pages/6If73mSRMTBP6L5Cnsdg" %} [Retrievals from Knowledge Search Blocks](/callable/use-cases/retrievals-from-knowledge-search-blocks) {% endcontent-ref %} {% content-ref url="/pages/rCylswM01ndTsCbMRMq3" %} [Chatbot with Google Search Assistance](/callable/use-cases/chatbot-with-google-search-assistance) {% endcontent-ref %} # Building a Company Help Desk {% embed url="" %} # Creating a Social Media Manager Chatbot ## Overview Let's imagine that we are responsible for managing the social media presence of an up and coming startup and would like the help of a language model to help write twitter posts. We want to create a chat bot that can answer questions as if it has the knowledge of an expert social media manager. Cortex makes the process of building a personalized chat bot fast and simple. Let's look at how this can be done with the power of Callable and Copilot. ## Getting Started Navigate to the **Callable Builder** tab in the top right of the navigation bar and go ahead and press **Create Callable**. Name your callable **"social-media-call"** and give the following description: > callable to support creating social media posts Select **Private** and choose the **Barebone** template callable before pressing **Create**. Once inside the Callable Builder, you should see two blocks: INPUT, OUTPUT. Since we are creating a Chatbot let's switch the **input type** in the **INPUT** block to **ChatDataset**.

Understanding Chat Inputs

## Chat Inputs Chat Callable's input is a message object that contains an array of messages. #### Message Object The `Message` object is a high-level entity that holds an array of individual message items. * `messages`: An array of message items. Each item in the array is an object that consists of two properties: 'role' and 'content'. #### Message Item Each message item is an individual message with its associated role. * `'role'` Role related to the message (e.g., 'user', 'assistant'). * `'content'` Text of the message. ### Example Here is an example of what a `Message` object might look like: ```javascript { "messages": [ { "role": "user", "content": "Hello, how can I help you?" }, { "role": "assistant", "content": "I'm here to assist you. What do you need?" }, { "role": "user", "content": "I need information on your new products." } ] } ```

Understanding Callable Blocks

Blocks are fundamental units that form logical sequences inside a Callable. They operate similarly to server-less functions, running independently yet capable of working in cohesion to create complex features. Think of each block as an individual piece in a larger puzzle that is your Callable. Every block has its unique role and introduces a new functionality to the Callable. This could be anything from making curl requests, leveraging large language models, extracting specific data, to retrieving knowledge. A key attribute of these blocks is that they can interact with one another by calling upon each other's results. This ability to collaborate makes them incredibly versatile and adaptable, allowing you to build intricate and sophisticated features by chaining them together in the Callables.

*** ## Callable Code and Model Blocks For this application, we want to create a callable that takes in chat inputs and outputs a response from a language model in the form of a message item (See [#understanding-chat-inputs](#understanding-chat-inputs "mention")). We want to start by creating two referable code blocks that return: 1. The question asked by the user 2. The history of the chat Both of these can be sourced from parsing the input message object with the following blocks. ### EXTRACT\_QUESTION Block This Code block returns the content of the last element in the message array

### HISTORY Block This Code block joins the content of every message in the array except the last message and returns it in a string.

Once we have parsed the History and Question from the input, we can references these inside a well designed prompt and send everything to ChatGPT. This can be done inside a Model Block. ### OUTPUT\_STREAM Block This Model block uses the return of the History block and the Extract Question block and wraps it into prompt that will help specify what kind of answer we want from ChatGPT. {% hint style="info" %} Notice that when referencing block variables inside the Model Block prompt section, we must use the syntax`{{BLOCK_NAME}}`. {% endhint %}

Lastly, we want to return the answer ChatGPT gives into a message item object. This can be done with a Code block again. ### GET\_ANSWER Block This Code block returns a message item object that contains content from the output of the OUTPUT\_STREAM Block.

## Test and Deploy Once you finish creating the necessary blocks for your callable. Go ahead and press **Run TestCases**. If there are no errors, you can deploy your callable by pressing **Deploy**. ## Creating Copilot After successfully deploying your callable, you can quickly turn your callable into a usable Chat Copilot. Navigate to **My Copilots** and click on **Create Copilot**. Name your Copilot **"Social Media Manager"** and enter the description > An expert social media content manager to generate tweets and posts for your brand! Select **Private** and choose **Chat**. Then press **Select Callable** and select **social-media-call**. Select **latest** for the version. Under **Example Prompts**, paste the following prompts: 1. Write a tweet to launch my new crypto startup: Kr1ptu@ 2. Write an Instagram post to announce that my sunglasses brand is now shipping to Europe 3. Write a Facebook post to say I'm offering 30% discount on my online coding courses Finally, click **Create Copilot.** ## Try it out! Go ahead and use your new chat copilot and see what tweets you can make! # Utilizing Model Examples to Convert Text to JSON ## Basic Model Block The basic Model Block accepts a specified prompt string and returns a Language Model completion as the result.

## Advanced Model Block The advanced Model Block provides parameters for the Introduction and Examples * **Introduction:** A paragraph that will appear at the beginning of your prompt once. Provides instruction to the model about how it should interpret your examples * **Examples:** Provide examples of the type of response you want the model to output. This could be a list of examples that are organized as a template question and answer. * **Prompt:** The final question that will appear at the end of the prompt that the user wants the model to complete.

## Converting Text to JSON In order to create a callable that can change plain text into a JSON, we need to provide examples for our model to reference back to so that the model would know what kind of output we are looking for. To do this, let's initialize our examples as an array of example objects with a question and an answer field. There are two ways to do this, the first way will use a code block.

We can also load examples using the Data Block and inputting the examples in the dataset tab.

That uses the following example dataset.

After initializing the examples, we can now set up an advanced language model block that has an introduction that describes our desired task to our model and then enter in our examples as a question followed by an answer. Finally, we enter our original input question as our prompt.

We can now run some test cases to see if this works. When we try the input:

We can see that our callable successful returns the JSON object as:

Once tested, deploy the callable to use in any application. # Retrievals from Knowledge Search Blocks ## Knowledge Search Block Search blocks allow Callables to make queries to uploaded Knowledges.

# Chatbot with Google Search Assistance This guide covers how to build a chat callable that refines user questions with Google Searches to obtain a response from a LLM that references data from websites. ## Getting Started Navigate to the **Callable Builder** tab in the top right of the navigation bar and go ahead and press **Create Callable**. Name your callable **"llm-with-google-assist"** and give the following description: > Answer questions with high factual accuracy by searching online and compiling responses based on content downloaded from websites (with references). Select **Private** and choose the **Barebone** template callable before pressing **Create**. Once inside the Callable Builder, you should see two blocks: INPUT, OUTPUT. Since we are creating a Chatbot let's switch the **input type** in the **INPUT** block to **ChatDataset**.

Understanding Chat Inputs

Understanding Callable Blocks

## 1. Formatting Question for Search Query Message objects contain the entire conversation history as an array with the last message in the array from the user. In order to send a google search query, we first need to extract the relevant context of the conversation to enhance the user’s question and receive correct search results. To do this, click the plus and create two code blocks: one to extract the question and the second to extract the conversation history.

Once we extract the question and history with the respected code blocks, we can refine our question with a language model so that it will include the context of the history inside a Model Block.

For the model configuration, we want a temperature of 0.1 for a more conservative change and so that our original question is not altered dramatically. ## 2. Google Search and Summarizing Results After refining our question, we want to create a google search query using the result from the REFINED\_QUESTION block that will provide links to relevant websites.

Our google search query provides us with a few of the most relevant links related to our query. In order to extract the information from these links, we must utilize a Map Reduce block and call a web crawler block on each link to retrieve the details from the google search results. In order to extract the relevant links and web crawl over them, we want to simplify our GOOGLE\_SEARCH object into a result object with a field for the title and link before starting our Map Reduce block. This can be done with another Code block.

Now with a list of relevant links formatted correctly, we can start a Map Reduce loop to collect a summary of each link.

This loop begins by calling upon a Web Page Crawler Block with each link to retrieve the HTML body of the page.

Then, another code block is called upon with the web crawler data to format into content blocks with only the first 2000 bytes of the HTML body.

Once the data is collected, a language model block can help us summarize the raw data from the HTML body into a single paragraph for which we can use in our final prompt.

The last block in the loop is a code block that nicely formats the link summaries into an object for us to reference in our final prompt.

## 3. Final Prompt and Returning Result Lastly, we need to combine the data from all relevant links together along with the original question into a single prompt before sending to our language model. This can be done with a code block that loops through each FORMAT\_SUMMARY object to extract the summary of the links and append it into a single string with the original question.

Once this is finished, the last step is to run the final prompt in a language model prompt and extract the results.

*** Congratulations, you have created a chatbot that uses google search to find relevant information about the question. Create some test cases and deploy your callable to start using it in any application. ## Clone callable # Getting Started with the SDK ## Installation {% tabs %} {% tab title="Typescript" %}

npm install cortex-ts

{% endtab %} {% tab title="Python" %} ```bash pip install trycortex ``` {% endtab %} {% endtabs %} ## Create a CortexAPI Create environment variables for your cortex API key. Use the API key to create a CortexAPI. {% tabs %} {% tab title="Typescript" %} ```typescript import { CortexAPI } from 'cortex-ts'; const {CORTEX_API_KEY} = process.env; const cortex = new CortexAPI(CORTEX_API_KEY); ``` {% endtab %} {% tab title="Python" %} ```python import cortex CortexAPI = cortex.CortexAPI(API_KEY) ``` {% endtab %} {% endtabs %} # Documents ## Retrieving a Document First, find the name of the knowledge that contains the document you wish to retrieve in the knowledge tab of Cortex.

Then, find the name of the documentID you want to retrieve.

Use the knowledgeName and documentID with the `.getDocument` function of cortex to retrieve the document. See the Node.js Library for the exact .json return structure. {% tabs %} {% tab title="Typescript" %} ```javascript try { const res = await cortex.getDocument('tigers','testing.txt') const document = res.data.document console.log(document.text); } catch (error) { if (error.response) { console.log(error.response.status); console.log(error.response.data); } else { console.log(error.message); } } ``` {% endtab %} {% tab title="Python" %} ```python CortexAPI.getDocument('tigers','testing.txt') ``` {% endtab %} {% endtabs %} ## Uploading a Document Find the knowledgeName of the desired location of the document. Create an object that follows the createDocument interface to upload. {% tabs %} {% tab title="Typescript" %} ```javascript interface createDocument { timestamp?: number; tags?: string[]; text?: string | null; source_url?: string | null; }; ``` {% endtab %} {% tab title="Python" %} ```python class CreateDocument: def __init__( self, timestamp: Union[int, None] = None, tags: List[str] = None, text: Union[str, None] = None, source_url: Union[str, None] = None ): self.timestamp = timestamp self.tags = tags self.text = text self.source_url = source_url ``` {% endtab %} {% endtabs %} Use the documentID parameter to name the document you want to upload. {% tabs %} {% tab title="Typescript" %} ```javascript const test = { "source_url": "https://www.test.com/", "text": "test" } try { let output = await cortex.uploadDocument('tigers','test1',test); console.log(output.data.document); } catch (error) { if (error.response) { console.log(error.response.status); console.log(error.response.data); } else { console.log(error.message); } } ``` {% endtab %} {% tab title="Python" %} ```python test = cortex.CreateDocument() test.source_url = "https://www.test.com/" test.text = "test" CortexAPI = cortex.CortexAPI("sk-...") CortexAPI.uploadDocument('tigers','test1',test) ``` {% endtab %} {% endtabs %} ## Deleting a Document {% tabs %} {% tab title="Typescript" %} ```javascript try { let output = await cortex.deleteDocument('tigers','test1'); console.log(output.data.document); } catch (error:any) { if (error.response) { console.log(error.response.status); console.log(error.response.data); } else { console.log(error.message); } } ``` {% endtab %} {% tab title="Python" %} ```python CortexAPI.deleteDocument('tigers','test1') ``` {% endtab %} {% endtabs %} # Introduction Interact with our API with HTTP requests or use our Node.js or Python Libraries. Install our Node.js library with the following command ```bash npm install cortex-ts ``` # Authentication Cortex uses an API key to authenticate HTTP requests. Find your API key in the drop down of your profile where it says View API Keys.

API requests should include your API key in the HTTP header. ```http Authorization: Bearer CORTEX_API_KEY ``` # Making Curl Requests ## Callables After deploying a Callable, Cortex provides the direct curl request to send inputs to. ```sh curl -L https://trycortex.ai/api/sdk/p/[pID]/a/[aID]/r \ -H "Authorization: Bearer $CORTEX_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "version": 1, "config": { "OUTPUT_STREAM":{ "provider_id":"openai", "model_id":"gpt-3.5-turbo-16k", "use_cache":true, "use_semantic_cache":false}, "RETRIEVALS":{ "knowledge":[{ "project_id":"$pID", "data_source_id":"$DATASOURCE"}], "top_k":10, "filter":{"tags":null,"timestamp":null}, "use_cache":false}}, "blocking": true, "inputs": [{ "Key": "Value" }] }' ``` By providing a specified key and value pairs into the input, the HTTP response will contain a json with the corresponding output from the callable. ### Request body | Name | Description | | -------------------- | ----------------------------------------------------------------------------- | | `version (Required)` | (`integer \| 'latest'`) specify which version of the callable you want to run | | `config (Required)` | (`object`) configures the callable blocks | | `inputs (Required)` | (`array`) array of key and value pairs that will be sent to the callable | ## Documents Example curl request ```bash curl -L https://trycortex.ai/api/sdk/p/[pID]/knowledge/[knowledgeName]/d/[docID] \ -H "Authorization: Bearer $CORTEX_API_KEY" \ -H "Content-Type: application/json" \ -d '{ “text”: “value” }' ``` ### Request body * text (string) * the document text # Node.js Library {% embed url="" %} ## Documents #### .getDocument(knowledgeName: string, documentID: string) The function `.getDocument` takes in two parameters: `knowledgeName` and `documentID`. It retrieves a specific document from a specified knowledge base. The function returns an `AxiosPromise` with the document object. Example return json:

{
    "document": {
        "created": integer,
        "document_id": string,
        "timestamp": integer,
        "tags": string[],
        "source_url": string,
        "hash": string,
        "text_size": integer,
        "chunk_count": integer,
        "chunks": [],
        "text": string
    } 
}

#### .uploadDocument(knowledgeName: string, documentID: string, document: createDocument) The function `.uploadDocument` takes in three parameters: `knowledgeName`, `documentID`, and `document`. It uploads a new document to a specified knowledge base. The function returns an `AxiosPromise` with the newly uploaded document object and the knowledge object that the document was uploaded to. The Document object has the following interface: ```javascript interface createDocument { timestamp?: number; tags?: string[]; text?: string | null; source_url?: string | null; }; ``` Example return json: ```javascript { "document": { "created": integer, "document_id": string, "timestamp": integer, "tags": [], "source_url": string, "hash": string, "text_size": integer, "chunk_count": integer, "chunks": [ { "text": string, "hash": string, "offset": 0, "vector": [], "score": null } ] }, "knowledge": { "name": string, "description": string, "visibility": "private" | "public", "config": "{\"provider_id\":\"openai\",\"model_id\":\"text-embedding-ada-002\",\"extras\":null,\"splitter_id\":\"base_v0\",\"max_chunk_size\":365,\"use_cache\":false}", "runnerProjectId": string, "lastUpdatedAt": string, "hub": null } } ``` #### .deleteDocument(knowledgeName: string, documentID: string) The function `.deleteDocument` takes in two parameters: `knowledgeName` and `documentID`. It deletes a specific document from a specified knowledge base. The function returns an `AxiosPromise` with the deleted document object. ## Callable #### `.runCallable(callableID: string, data: CallableParams): AxiosPromise<{run: RunType}>` This function runs a callable identified by `callableID` with the given `data`. The `data` parameter must be an object of type `CallableParams` which includes the `version`, `config`, `inputs`, `blocking`, and `block_filter` properties. The `version` property specifies the version of the callable to run. The `config` property is an object of configuration parameters for the callable. The `inputs` property is an array of input values for the callable. The `blocking` property is a boolean that specifies whether the function should wait for the callable to complete before returning. The `block_filter` property is an array of block status filters for the callable. The function returns a promise that resolves to an object of type `AxiosPromise<{run: RunType}>` which includes the status of the run. #### `.runCallableWithStream(callableID: string, data: CallableParams): AxiosPromise` This function runs a callable identified by `callableID` with the given `data` and streams the output. The `data` parameter must be an object of type `CallableParams` which includes the `version`, `config`, `inputs`, `blocking`, and `block_filter` properties. The `version` property specifies the version of the callable to run. The `config` property is an object of configuration parameters for the callable. The `inputs` property is an array of input values for the callable. The `blocking` property is a boolean that specifies whether the function should wait for the callable to complete before returning. The `block_filter` property is an array of block status filters for the callable. The function returns a promise that resolves to an object of type `AxiosPromise` which includes the streamed output of the callable. #### `.runChatCompletion(version: string, messages: Message[], input: string, projectID:string, knowledgeName: string, copilotID: string)` | Name | Description | | --------------- | ------------------------------------------------------------------------------- | | `version` | (`string`) `"latest"` \| version number | | `messages` | (`Message[]`) array of messages previously sent to the chat callable | | `input` | (`string`) chat message that wants to be answered | | `projectID` | (`string`) projectID of user who created the knowledge that is being referenced | | `knowledgeName` | (`string`) name of knowledge being referenced | | `copilotID` | (`string`) ID of chat copilot | # Python Library Coming Soon!