> ## Documentation Index
> Fetch the complete documentation index at: https://docs.isomeric.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Prompting

> Using Isomeric is like prompting an LLM. Behind every Isomeric prompt is an LLM trained on billions of tokens of text.

## Prompt Overview

An Isomeric prompt is the JSON schema passed in the `schema` key of your request POST body. Each schema strictly follows the [JSON Schema spec](https://json-schema.org/).

A valid Isomeric POST request body looks like this:

```json theme={null}
{
  "text": [YOUR INPUT TEXT],
  "schema": {
    "type": "object",
    "properties": {
      "title": {
        "description": "The title of the main product described in the text",
        "type": "string"
      }
    }
  }
}
```

## Prompt Design

Designing the right prompt is critical to extracting the right data. Our LLM processes your prompt from top to bottom, and each key/value is its own pass through the model, including any previously generated data. This means that generating a `title` before generating a `price` will get you a better result because the price being generated will be inferred given the context of the title.

For example:

```json theme={null}
{
  "type": "object",
  "properties": {
    "price": {
      "description": "Dollar and cents representation of the price of the main product in the provided text",
      "type": "number"
    }
  }
}
```

This prompt requests the price. Let's say you are getting the price of an item on Amazon. Typically there are many products (primary, related, frequently bought with) on a single page, and this prompt does not clearly indicate which price you would like to extract, so there is a high likelihood that the LLM will not get it right.

However, this prompt:

```json theme={null}
{
  "type": "object",
  "properties": {
    "title": {
      "type": "string"
    },
    "price": {
      "type": "string"
    }
  }
}
```

will run two full passes through the model. First to generate the title and second to generate the price. When generating the `price` output the prompt sent to the model will actually be:

```json theme={null}
{
  "title": "LEGO Architecture London Model 2201",
  "price": "
```

The model will continue generating from this point; therefore, the price will be strongly tied to the title.

The best approach is to play around with your prompts with multiple sources (i.e., website URLs) until you get the results you're looking for.

Another approach to take for improved results is nesting. For example, if you are looking for `recipe` data, it's best to make that your top-level object. Like this:

```json theme={null}
{
  "type": "object",
  "properties": {
    "recipe": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string"
        },
        "ingredients": {
          "type": "array"
          "items": {
            "type": "object"
            "properties": {
              "ingredient": {
                "type": "string",
              },
              "measure": {
                "type": "string",
              }
              "amount": {
                "type": "number",
              }
            }
          }
        },
        "steps": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    }
  }
}
```

## Descriptions

The `description` value is the most powerful value to consider when designing your prompt. This informs the LLM what data specifically you're looking for. Use plain english when describing the data definition. For example:

```json theme={null}
{
  "type": "object"
  "properties": {
    "shipping": {
      "description": "The total calculated shipping costs of all items in the user's shopping cart represented in dollars and cents."
      "type": "number"
    }
  }
}
```

## Types

Every key in a prompt needs a valid type. This will not only constrain the model to generate that type, it will also instruct the model on how to generate responses based on the type.

### String

When you want a single-string response, use `string`. This is good for things like titles, descriptions, summaries, etc.

```json theme={null}
{
  "first_name": {
    "type": "string"
  }
}
```

Will produce

```json theme={null}
{
  "first_name": "Kelley"
}
```

### Number

The `number` type will constrain the model only to generate a number as a result. Valid number examples are: `2`, `22`, `22.01`, and `22.202`. The resulting JSON will be a number therefore *not* wrapped in quotes.

```json theme={null}
{
  "amunt": {
    "type": "number"
  }
}
```

Will produce

```json theme={null}
{
  "amount": 22
}
```

### Boolean

`boolean` types will return only `true` or `false`. This type is great for keys used to determine something like page type. For example:

```json theme={null}
{
  "is_product_detail_page": {
    "type": "boolean"
  }
}
```

Will produce

```json theme={null}
{
  "is_product_detail_page": true
}
```

### Object

Isomeric objects are powerful prompt types that contain children types. These are important in both generating the output you desire as well as in designing prompts that will yield the best results.

Every `object` must have a `properties` key describing each property of the object.

For example:

```json theme={null}
{
  "contact_details": {
    "type": "object",
    "properties": {
      "first_name": {
        "type": "string"
      },
      "last_name": {
        "type": "string"
      },
      "email": {
        "type": "string"
      },
      "phone": {
        "type": "string"
      }
    }
  }
}
```

Will produce

```json theme={null}
{
  "contact_details": {
    "first_name": "Kelley",
    "last_name": "Morris",
    "email": "kmorris92@bayside-high.edu"
    "phone": "310-555-5252"
  }
}
```

### Array

Isomeric can produce lists of content. Every `array` type must have an `items` attribute describing each item of the array. Let's use reviews as an example.

```json theme={null}
{
  "reviews": {
    "type": "array",
    "items": {
      "type": "object"
      "properties": {
        "date": {
          "type": "string"
        },
        "author": {
          "type": "string"
        },
        "review": {
          "type": "string"
        },
        "sentiment": {
          "type": "string"
        }
      }
    }
  }
}
```

Will produce

```json theme={null}
{
  "reviews": [{
    "date": "12-16-1986",
    "author": "Zack Morris",
    "reviews": "Bayside High is far out.",
    "sentiment": "positive",
  }, {
    "date": "12-15-1986",
    "author": "Kelley Kapowski",
    "reviews": "High school at Bayside was a dream come true.",
    "sentiment": "positive",
  }]
}
```

#### Max Items

You can add `max_items` to control how many items in the list you want generated. This can be specified like so:

```json theme={null}
{
  "similar_products": {
    "type": "array",
    "max_items": 4,
    "items": {...}
  }
}
```

## Attributes

### Stop

As mentioned, Isomeric is an LLM trained on billions of tokens of website data. For every key/value pair, the model runs a full pass from start to finish. Just like working with other LLMs, you need to tell it when to stop generating new tokens. For every `type` specified above, we have added a default stop sequence. You can override these by specifying your own via the `stop` key like so:

```json theme={null}
{
  "email_inbox": {
    "type": "string",
    "stop": "@"
  }
}
```

### Max Tokens

You can control how many tokens are generated per key with the `max_tokens` attribute like so:

```json theme={null}
{
  "title": {
    "type": "string",
    "max_tokens": 10
  }
}
```

### Pattern

`Pattern` is a powerful tool to use regular expressions giving you fine-grained control of the output of the model. Remember that because this is being passed in as `json` you need to escape your escape characters too.

This is an example that will constrain the model to produce prices according to a strict format:

```json theme={null}
{
  "price": {
    "type": "string",
    "pattern": "\\d+\\.\\d{2}"
  }
}
```

### Options

You can constrain the model to a list of options to choose from. For example, given the following prompt:

```json theme={null}
{
  "color": {
    "type": "string",
    "options": ["red", "green", "blue"]
  }
}
```

the model will only produce either `red`, `green`, or `blue`.

### Nullable

`strings`, `numbers`, and `booleans` can be marked as `nullable`. This is helpful to prevent the model from hallucinating if a value does not exist on a website. In which case, a `nullable` type will return `null` instead of producing a hallucinated value because no value exists.

```json theme={null}
{
  "color": {
    "type": "string",
    "nullable": true
  }
}
```