• Generative AI Basics: You should be familiar with what generative AI is and how it works. At a minimum, understand that it involves models like GPT, LLaMA, or Stable Diffusion that can generate text, images, or other media based on a given prompt.
  
• Foundation Models: Some exposure to foundation models (e.g., GPT-4, LLaMA 3, Mistral) and how they are used as building blocks for AI applications will make it easier to understand how guardrails are applied to them.
  
• DigitalOcean Account: To follow along or test out examples, you’ll need an active DigitalOcean account. You should also be familiar with basic account navigation within the DigitalOcean Console.
  
• Agent and RAG Pipelines (Optional but Helpful): If you’ve worked with agents or retrieval-augmented generation pipelines before, you’ll have a head start.
  

Sensitive Data Detection

• Detects information like credit card numbers, IP addresses, social security numbers, and other personally identifiable information (PII).
• Fully customizable—developers can choose which categories to detect.

Jailbreak Detection

• Blocks attempts to manipulate or bypass the model’s safety mechanisms.
• Useful for preventing prompt injection attacks and misuse.

Content Moderation

• Flags and intercepts content that is offensive, violent, explicit, or hateful.
• Helps keep applications aligned with content policies.

Attach Multiple Guardrails to a Single Agent

Attach a Guardrail to Multiple Agents**

• Click Customize categories
• Check or uncheck the boxes for the specific data types you want to include.

Save the Duplicated Guardrail

1. Customize and Caution: Every AI application is different, and so are its users. When adding or tweaking guardrail settings, it’s important to test with real-world prompts. Try prompts that mimic what your end users might actually type. This will help you understand how the model responds and whether it blocks or allows content appropriately. A too-strict guardrail might stop legitimate use cases, while a too-lenient one could let risky content through. Always strike a balance between safety and usability.
   
2. Use Duplicates for Flexibility: DigitalOcean’s guardrail system lets you duplicate configurations. For example, you might need stricter content filters for a customer support chatbot, but a more open setup for an internal tool. By duplicating a base configuration, you can customize each version independently, without affecting the original settings.
   
3. Monitor and Iterate Often: AI keeps changing; hence, after deploying an agent, always make it a habit to review the agent. This gives you valuable feedback. Are you blocking too much content? Not enough? Use these insights to fine-tune detection categories and thresholds over time. Think of it like tuning a radio: small adjustments can make a big difference in clarity and performance.
   

• Safeguarding LLMs with Guardrails
• Top 20 LLM Guardrails With Examples
• How to implement LLM guardrails
• What are LLM Guardrails? Essential Protection for AI Systems
• Create and Manage Guardrails
• What is Adversarial Machine Learning?
• A Deep Dive into LLM Guardrails

Step 1a: Create a DigitalOcean API Key

Step 2A: Create a Model Access key with the API

curl -X POST -H 'Authorization: Bearer $DIGITALOCEAN_TOKEN' https://api.digitalocean.com/v2/gen-ai/models/api_keys

Step 2B: Create a Model Access key with the Cloud Console

Step 3: Generating Text with Python and Serverless Inference

from openai import OpenAI
import os

client = OpenAI(
    api_key= **“your_model_access_key_here”**,
    base_url="https://inference.do-ai.run/v1"
)

stream = client.chat.completions.create(
    model="llama3-8b-instruct",
    messages=[
        {
            "role": "developer",
            "content": "You are a helpful assistant.",
        },
        {
            "role": "user",
            "content": "What is the capital of France?",
        },
    ],
    stream=True,
    max_completion_tokens=10
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

• Event driven applications: Where a specific occurrence triggers the run of the LLM, this is common in agentic use cases
• Scalable backend services: When the inference on the backend may need to be scaled indefinitely, serverless can guarantee that your users will never be left waiting
• Data processing: batch jobs and data processing can be handled effectively and efficiently without requiring costly setup Source
• And much more!

cd my-new-project/
gemini
> Help me understand the PDF in this directory. And also provide a summary of the documents.

cd some-huge-repo/
gemini
> Describe the main architecture of this system.

gemini
> Convert all images in this folder to PNG and name them using the EXIF date.

npx https://github.com/google-gemini/gemini-cli

npm install -g @google/gemini-cli
gemini

• For simple ASCII strings, use std::transform or a range-based for-loop for efficient and readable in-place case conversion in C++.
• To prevent undefined behavior, always cast characters to unsigned char before passing them to standard library functions like std::toupper and std::tolower.
• Standard C++ toupper and tolower functions are not Unicode-aware and can fail on international characters, as they only support one-to-one character mapping.
• For reliable, locale-aware case conversion in applications handling international text, you must use a dedicated library like ICU (International Components for Unicode).
• The ICU library correctly handles complex, one-to-many character mappings (e.g., German ‘ß’ to ‘SS’) that the standard C++ library cannot.
• Never use manual ASCII arithmetic (e.g., char - 32) in production code; it is unsafe, not portable, and only works for basic English characters.

Method 1: The Standard C++ Way with std::transform

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>

int main() {
    std::string input_text = "Hello World!";

    std::transform(input_text.begin(), input_text.end(), input_text.begin(), ::toupper);

    std::cout << "Result: " << input_text << std::endl;
    
    return 0;
}

Method 2: The Simple For-Loop

#include <iostream>
#include <string>
#include <cctype>

int main() {
    std::string input_text = "This is a DigitalOcean tutorial!";

    for (char &c : input_text) {
        c = std::toupper(static_cast<unsigned char>(c));
    }

    std::cout << "Result: " << input_text << std::endl;

    return 0;
}

Method 3: Manual ASCII Math

#include <iostream>
#include <string>

int main() {
    std::string my_text = "Manual conversion";

    for (char &c : my_text) {

        if (c >= 'a' && c <= 'z') {
            c = c - 32; 
        }
    }

    std::cout << "Result: " << my_text << std::endl;

    return 0;
}

Method 1: Using std::transform

#include <iostream>
#include <string>
#include <algorithm> 
#include <cctype>   

int main() {
    std::string my_text = "THIS IS A LOUD SENTENCE.";

    std::transform(my_text.begin(), my_text.end(), my_text.begin(), ::tolower);

    std::cout << "Result: " << my_text << std::endl;

    return 0;
}

Method 2: Using a Traditional For-Loop

#include <iostream>
#include <string>
#include <cctype>

int main() {
    std::string my_text = "ANOTHER EXAMPLE.";

    for (size_t i = 0; i < my_text.length(); ++i) {
        my_text[i] = std::tolower(static_cast<unsigned char>(my_text[i]));
    }

    std::cout << "Result: " << my_text << std::endl;

    return 0;
}

Method 3: Manual ASCII Manipulation

#include <iostream>
#include <string>

int main() {
    std::string my_text = "MANUAL CONVERSION";

    for (char &c : my_text) {

        if (c >= 'A' && c <= 'Z') {
            c = c + 32; 
        }
    }

    std::cout << "Result: " << my_text << std::endl;

    return 0;
}

The Standard C++ Approach: std::wstring and std::locale

#include <iostream>
#include <string>
#include <algorithm>
#include <locale>

int main() {

    std::locale::global(std::locale(""));
    std::wcout.imbue(std::locale());

    std::wstring text = L"Eine Straße in Gießen.";
    const auto& facet = std::use_facet<std::ctype<wchar_t>>(std::locale());

    std::transform(text.begin(), text.end(), text.begin(), [&](wchar_t c){
        return facet.toupper(c);
    });

    std::wcout << L"std::locale uppercase: " << text << std::endl;
    return 0;
}

std::locale uppercase: EINE STRAßE IN GIEßEN.

How to Use ICU for Case Conversion

#include <unicode/unistr.h>
#include <unicode/locid.h>
#include <iostream>

int main() {
    std::string input = "Eine Straße in Gießen.";

    icu::UnicodeString ustr = icu::UnicodeString::fromUTF8(input);

    ustr.toUpper(icu::Locale("de"));

    std::string output;
    ustr.toUTF8String(output);

    std::cout << "Unicode-aware uppercase: " << output << std::endl;
    return 0;
}

• icu::UnicodeString::fromUTF8(input) converts the standard std::string into ICU’s core string class, UnicodeString. This is the necessary first step, as ICU’s functions operate on this specialized type.
• .toUpper(icu::Locale("de")) is the key function. It applies the case conversion rules defined by the German (de) icu::Locale object. This method correctly handles the one-to-many mapping of ß to SS.
• .toUTF8String(output) converts the result from ICU’s internal format back into a standard std::string so it can be easily used with std::cout and other C++ components.

Unicode-aware uppercase: EINE STRASSE IN GIESSEN.

• std::transform vs. For-Loop: For typical string lengths, the performance of these two methods is virtually identical. Modern compilers are exceptionally good at optimizing simple loops and standard algorithms, often generating the same machine code for both. For very large strings, std::transform can sometimes have a slight edge, as it more clearly expresses the intent to the compiler, which may apply advanced optimizations like vectorization.
• Manual ASCII Math: In micro-benchmarks with pure English text, this method is often the fastest as it avoids any function call overhead. However, this minuscule gain is not worth the cost. The if statement can lead to CPU branch mispredictions if the text is a mix of cases, and the method is fundamentally unsafe and non-portable.
• ICU Library: ICU is a highly optimized library. For simple ASCII text, it will be slower than the native C++ methods due to the overhead of creating UnicodeString and Locale objects. However, for its intended purpose, i.e., processing complex, international Unicode text, its performance is excellent and far surpasses the incorrect attempts of the standard library.

Memory Efficiency Considerations

• In-Place Modification: This is the most memory-efficient approach. Using std::transform on the source string or iterating with a for-loop and a reference (&c) modifies the string’s existing memory without allocating a new buffer. This should be your default method.
• Creating Copies: If you need to preserve the original string, you must create a copy (std::string new_str = old_str;). This temporarily doubles the memory usage for that string. Do this only when necessary.
• ICU Memory: The icu::UnicodeString object has its own memory management and will have a different memory footprint than std::string. This is a necessary trade-off for the powerful features and correctness it provides.

Best Practices

• Prioritize Correctness Over Micro-optimizations: A program that is 0.01% faster but corrupts international text is a broken program. For any user-facing text, correctness is paramount.
• Always Use unsigned char with Standard Functions: To prevent undefined behavior, always cast your char to unsigned char before passing it to std::toupper or std::tolower.

c = std::toupper(static_cast<unsigned char>(c));

• Modify In-Place for Efficiency: Unless you need to preserve the original string, use in-place operations to conserve memory and avoid the overhead of new allocations.
• Know Your Data: Assume Unicode: If your application handles text from any external source (users, files, APIs), assume it is Unicode. Use the ICU library for all case conversions to ensure correctness. Standard methods are only safe for internal, hard-coded ASCII strings.
• Choose Readability: The performance difference between std::transform and a for-loop is almost always negligible. Choose the method that you and your team find more maintainable.
• Never Use Manual ASCII Math in Production: This approach is unsafe, not portable, and will fail on non-English text. It should be avoided entirely.

1. How do I convert a string to uppercase in C++?

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>

int main() {
    std::string input_text = "Hello World!";

    std::transform(input_text.begin(), input_text.end(), input_text.begin(), ::toupper);

    std::cout << "Result: " << input_text << std::endl;
    
    return 0;
}

2. Is toupper() safe for all locales?

3. Can I use C-style strings with these methods?

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype> 

int main() {

    const char* c_style_string = "hello from a c-style string!";

    std::string my_string = c_style_string;

    std::transform(my_string.begin(), my_string.end(), my_string.begin(), ::toupper);

    std::cout << "Result: " << my_string << std::endl;

    return 0;
}

4. How do you check if a string contains both uppercase and lowercase letters in C++?

#include <string>
#include <cctype>

bool has_both_cases(const std::string& s) {
    bool has_lower = false;
    bool has_upper = false;
    for (char c : s) {
        if (std::islower(c)) has_lower = true;
        if (std::isupper(c)) has_upper = true;
        if (has_lower && has_upper) return true; 
    }
    return has_lower && has_upper;
}

5. How do you convert all uppercase to lowercase in C++?

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>

int main() {
    std::string input_text = "HELLO WORLD!";

    std::transform(input_text.begin(), input_text.end(), input_text.begin(), ::tolower);

    std::cout << "Result: " << input_text << std::endl;
    
    return 0;
}

6. Why doesn’t std::toupper work correctly for characters like ‘ß’ or ‘é’?

• One-to-One Mapping Limitation: The standard C++ toupper function is designed to take one character and return exactly one character. It is fundamentally incapable of handling conversions like the German ß to the two-character string SS.
• Encoding Issues: When used on a UTF-8 std::string, std::toupper operates byte-by-byte. It sees a multi-byte character like é as two separate, meaningless bytes and cannot convert it correctly.

• How to Reverse a String in C++: A Guide with Code Examples - Learn multiple methods to reverse strings in C++, including using STL algorithms, iterators, and manual character swapping. Understand the performance implications and best practices for each approach.
  
• 3 Ways to Compare Strings in C++ - Master string comparison in C++ using operators, member functions, and C-style functions. Covers case-sensitive and case-insensitive comparisons, as well as handling special cases like substrings.
  
• How to Find the Length of an Array in C++ - Explore different techniques to determine array sizes in C++, including using sizeof(), std::size(), and other methods. Learn about limitations and best practices when working with arrays of different types.
  

• C++ String to Uppercase
• C++ String to LowerCase

RewardBench 2 Domains

Method of Generating Completions

Scoring

1. Domain-level measurement: Accuracy scores are first calculated separately for each individual domain
2. Final score calculation: The overall final score is computed as an unweighted average of the accuracy scores across all six domains

You may also notice that a number of different models are being used in the models column. The researchers found that RMs tend to prefer completions generated by their own base model and therefore used a pool of models for the different domains.

• Python’s built-in float() function handles most string-to-float conversions, including integers, decimals, negative numbers, scientific notation, and strings with leading/trailing whitespace.
• Wrap float() conversions in try-except blocks to catch ValueError exceptions from invalid strings like "hello" or empty strings, preventing program crashes.
• Use string replacement methods (remove commas, replace decimal separators) or Python’s locale module to convert European-style numbers like "1.234,56" to standard format.
• float(None) raises a TypeError, not ValueError; so explicitly check for None values before attempting conversion to avoid different exception types.
• Remove unwanted characters like currency symbols, thousands separators, and whitespace using string methods like .strip() and .replace() before calling float().
• Build utility functions like safe_to_float() that handle common edge cases (None, empty strings, invalid input) and return sensible defaults to make your code more maintainable and robust.

• Handling User Input: Getting numbers from users for calculations, such as in a tip calculator or a financial application.
• Data Processing: Parsing numerical data from files like CSVs, JSON, or text files where numbers are often stored as strings.
• Web Scraping: Extracting product prices, ratings, or other numerical data from websites, which are always retrieved as text.
• API Integration: Receiving data from external APIs where numerical values are sometimes formatted as strings.

• Familiarity with basic Python programming. Check out How to Code in Python 3 series or using VS Code for Python for a quick lesson.

float(your_string)

1. Converting a Standard Numeric String

price_string = "24.99"
print("Type before conversion:", type(price_string))

price_float = float(price_string)
print("Type after conversion:", type(price_float))

Type before conversion: <class 'str'>

Type after conversion: <class 'float'>

2. Converting a String Representing an Integer or Negative Number

# String representing an integer
int_string = "350"
print(f"'{int_string}' becomes: {float(int_string)}")

# String representing a negative decimal
neg_string = "-45.93"
print(f"'{neg_string}' becomes: {float(neg_string)}")

'350' becomes: 350.0
'-45.93' becomes: -45.93

3. Handling Leading/Trailing Whitespace

reading_string = "  -99.5  "
reading_float = float(reading_string)

print(reading_float)

-99.5

Converting Scientific Notation

scientific_string = "1.5e10"
scientific_float = float(scientific_string)

print(f"'{scientific_string}' becomes: {scientific_float}")
print(type(scientific_float))

'1.5e10' becomes: 15000000000.0
<class 'float'>

Understanding the ValueError Exception

invalid_string = "not a number"

price_float = float(invalid_string)

print(price_float)

Using try-except Blocks for Safe Conversion

• The try block contains the code that might fail (the “risky” operation).
• The except block contains the code that runs only if an error occurs in the try block.

input_string = "not a number"
value_float = 0.0 

try:
  value_float = float(input_string)
  print("Conversion successful!")
except ValueError:
  print(f"Could not convert '{input_string}'.")

print(f"The final float value is: {value_float}")

Could not convert 'not a number'.
The final float value is: 0.0

Handling Empty Strings and None Values

• Empty Strings: An empty string is not a valid number, so float("") will also raise a ValueError. The try-except block we just created handles this perfectly.
• None Values: Trying to convert None is a different kind of error. float(None) will raise a TypeError, not a ValueError. If your code encounters None, you should check for it explicitly before trying the conversion.

def safe_to_float(value):
  if value is None:
    return 0.0
  try:
    return float(value)
  except (ValueError, TypeError):
    return 0.0

# Test cases 
print(f"'123.45' becomes: {safe_to_float('123.45')}")
print(f"'hello' becomes: {safe_to_float('hello')}")
print(f"An empty string '' becomes: {safe_to_float('')}")
print(f"None becomes: {safe_to_float(None)}")

'123.45' becomes: 123.45
'hello' becomes: 0.0
An empty string '' becomes: 0.0
None becomes: 0.0

1. The String Replacement Method

1. Remove the thousands separators.
2. Replace the comma decimal separator with a period.

de_string = "1.234,56"

temp_string = de_string.replace(".", "")

standard_string = temp_string.replace(",", ".")

value_float = float(standard_string)

print(f"Original string: '{de_string}'")
print(f"Standardized string: '{standard_string}'")
print(f"Converted float: {value_float}")

Original string: '1.234,56'
Standardized string: '1234.56'
Converted float: 1234.56

2. Using the locale Module

import locale

de_string = "1.234,56"

try:
    locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')

    value_float = locale.atof(de_string)
    
    print(f"Successfully converted '{de_string}' to {value_float}")

except locale.Error:
    print("Locale 'de_DE.UTF-8' not supported on this system.")
finally:
    locale.setlocale(locale.LC_NUMERIC, '')

Successfully converted '1.234,56' to 1234.56

• Always Wrap External Input in a try-except Block: This is the most critical rule. Data from users, files, or APIs is unpredictable. A try-except ValueError block will prevent your program from crashing due to a single invalid string and allow you to handle the error gracefully.
• Clean Your Strings Before Conversion: Don’t pass messy strings directly to float(). First, use string methods like .strip() to remove leading/trailing whitespace and .replace() to eliminate unwanted characters. For more advanced cleaning, you can review our article on common string manipulation techniques.
• Assign a Sensible Default Value: When a conversion fails inside an except block, decide on a fallback plan. Is it better to skip the entry, or should you assign a default value like 0.0 or None? This ensures your program can continue running with predictable data.
• Create a Helper Function for Repetitive Conversions: If you perform the same conversion logic in multiple places, encapsulate it in a reusable function (like the safe_to_float() example earlier). This makes your code cleaner, easier to read, and simpler to update.
• Be Aware of International Number Formats: If your application processes data from different parts of the world, remember that decimal separators can be commas instead of periods. Use the string replacement method for simple cases or the locale module for more complex, locale-aware applications.
• Stick with float() for Simplicity: For all standard conversions, the built-in float() function is the most direct, readable, and Pythonic tool for the job. Avoid overly complex solutions when a simple one works perfectly.

1. How do I convert a string to float in Python?

2. What happens if the string isn’t a valid float?

3. How do I convert a string with commas like “1,234.56”?

4. How to convert string to a float with 2 decimal in Python?

• For Display (Get a String): Use an f-string with the :.2f format specifier. This is best for printing or showing the value in a UI.

price_string = "49.99123"
formatted_price = f"{float(price_string):.2f}"
print(formatted_price)
# Output: "49.99"

• For Calculation (Get a Float): Use the built-in round() function. This is best if you need to use the rounded number in further math operations.

price_string = "49.99123"
rounded_price = round(float(price_string), 2)
print(rounded_price)
# Output: 49.99

5. What’s the difference between float() and int() when converting strings?

6. How do I handle scientific notation strings like “1.5e10”?

• How To Convert Data Types in Python 3
• How to Concatenate String and Int in Python (With Examples)
• How to Receive User Input in Python: A Beginner’s Guide
• Python Compare Strings - Methods & Best Practices

• float() official documentation

• Quick wins: Chart.js and ApexCharts are ideal for dashboards that need rapid, out‑of‑the‑box results.
• Performance matters: Canvas‑based libraries handle large datasets better; always throttle real‑time updates and test on mobile.
• Custom Visualization Engine: D3.js is the go-to tool for developers who need total design freedom and logic-driven visuals.
• Enterprise muscle: ECharts delivers rich features and blazing performance for large‑scale apps, while Plotly.js excels at scientific and 3‑D plots.
• Choose wisely: Library choice hinges on chart complexity, dataset size, performance, and UX requirements.

• General knowledge on how to work with HTML, CSS, and JS (ES6+).
• A code editor (like VS Code or Cursor) and a Browser with DevTools.
• Node.js (LTS) and a package manager like npm, Yarn, bun or pnpm.
• Optional but helpful: a bundler/build tool (Vite, Webpack, or Rollup).
• A sample dataset (CSV or JSON) to experiment with while following this guide.

Chart.js

const ctx = document.getElementById('myChart').getContext('2d');
const myChart = new Chart(ctx, {
    type: 'bar',
    data: {
        labels: ['Red', 'Blue', 'Yellow', 'Green', 'Purple', 'Orange'],
        datasets: [{
            label: '# of Votes',
            data: [12, 19, 3, 5, 2, 3],
            backgroundColor: 'rgba(54, 162, 235, 0.6)'
        }]
    },
    options: {
        responsive: true,
        plugins: {
            legend: { display: true },
            tooltip: { enabled: true }
        }
    }
});

D3.js

const data = [12, 19, 3, 5, 2, 3];
const svg = d3.select('#mySvg').attr('width', 400).attr('height', 200);

svg.selectAll('rect')
   .data(data)
   .enter()
   .append('rect')
   .attr('x', (d, i) => i * 40)
   .attr('y', d => 200 - d * 10)
   .attr('width', 35)
   .attr('height', d => d * 10)
   .attr('fill', 'steelblue');

ECharts

const chart = echarts.init(document.getElementById('main'));
const option = {
    xAxis: { type: 'category', data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'] },
    yAxis: { type: 'value' },
    series: [{
        data: [120, 200, 150, 80, 70],
        type: 'bar'
    }],
    tooltip: { trigger: 'axis' },
    toolbox: { feature: { saveAsImage: {} } }
};
chart.setOption(option);

ApexCharts

var options = {
    chart: { type: 'line', height: 350 },
    series: [{ name: 'Sales', data: [30, 40, 35, 50, 49, 60] }],
    xaxis: { categories: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun'] },
    tooltip: { enabled: true },
    responsive: [{ breakpoint: 480, options: { chart: { height: 300 } } }]
};
var chart = new ApexCharts(document.querySelector("#chart"), options);
chart.render();

Plotly.js

var data = [{
    x: [1, 2, 3, 4],
    y: [10, 15, 13, 17],
    type: 'scatter'
}];
Plotly.newPlot('plot', data);

1. What causes performance issues in JavaScript charts?**

2. How do I make my charts responsive across devices?

3. What are common accessibility mistakes with charts, and how can I address them?

4. Is it okay to display very large or complex datasets in a single chart?

5. What should I watch out for when updating chart data?

Further Reading

• Angular Chart.js with ng2-charts → - Learn how to integrate Chart.js with Angular using the ng2-charts wrapper library for dynamic data visualization
• Add Charts to SolidJS with ApexCharts → - Build interactive charts and graphs in SolidJS applications using the powerful ApexCharts library
• Creating Tables in HTML → - Master the fundamentals of creating and styling data tables in HTML for structured content presentation
• JavaScript Coding Series → - A comprehensive guide covering JavaScript fundamentals, advanced concepts, and best practices for modern web development

1. One key for everything: You don’t have to manage separate keys for OpenAI, Anthropic, Mistral, etc. One DigitalOcean API key gives you access to every model—Claude, GPT-4o, LLaMA 3, Mistral, and more.
2. Lower costs: For many workloads, this is significantly more cost-effective than going direct to the provider.
3. Unified billing: All your usage shows up in one place. Everything shows up in your DO bill, alongside your apps, spaces, databases, whatever else you’re running on DO. No surprise charges across different platforms.
4. Privacy for open models: If you’re using open-weight models (like LLaMA or Mistral), your prompts and completions aren’t logged or used for training.
5. *No SDK changes: The OpenAI SDK just works. You can also use libraries like LangChain or LlamaIndex the same way—just change the base URL.

• Serverless Inference (for general models): https://inference.do-ai.run/v1/
• Agents (for context-aware inferencing over your own data): https://.agents.do-ai.run/api/v1/

pip install openai python-dotenv

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()

client = OpenAI(
    base_url="https://inference.do-ai.run/v1/",  # DO's Inference endpoint
    api_key=os.getenv("DIGITAL_OCEAN_MODEL_ACCESS_KEY")
)

# List all available models
try:
    models = client.models.list()
    print("Available models:")
    for model in models.data:
        print(f"- {model.id}")
except Exception as e:
    print(f"Error listing models: {e}")

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()

client = OpenAI(
    base_url="https://inference.do-ai.run/v1/",  # DO's Inference endpoint
    api_key=os.getenv("DIGITAL_OCEAN_MODEL_ACCESS_KEY")
)

# Run a simple chat completion
try:
    response = client.chat.completions.create(
        model="llama3-8b-instruct",  # Swap in any supported model
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Tell me a fun fact about octopuses."}
        ]
    )
    print(response.choices[0].message.content)
except Exception as e:
    print(f"Error during completion: {e}")

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()

client = OpenAI(
    base_url="https://inference.do-ai.run/v1/",  # DO's Inference endpoint
    api_key=os.getenv("DIGITAL_OCEAN_MODEL_ACCESS_KEY")
)

# Run a simple chat completion with streaming
try:
    stream = client.chat.completions.create(
        model="llama3-8b-instruct",  # Swap in any supported model
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Tell me a fun fact about octopuses."}
        ],
        stream=True
    )
    for event in stream:
        if event.choices[0].delta.content is not None:
            print(event.choices[0].delta.content, end='', flush=True)
    print()  # Add a newline at the end

except Exception as e:
    print(f"Error during completion: {e}")

python
client = OpenAI(
    base_url="https://your-agent-id.agents.do-ai.run/api/v1/",
    api_key=os.getenv("DIGITAL_OCEAN_MODEL_ACCESS_KEY")
)

from openai import OpenAI
from dotenv import load_dotenv
import os
import json
load_dotenv()

try:
    # Create a new client with the agents endpoint
    agents_client = OpenAI(
        base_url="https://rrp247s4dgv4xoexd2sk62yq.agents.do-ai.run/api/v1/",
        api_key=os.getenv("AJOT_AGENT_KEY")
    )
    
        
    # Try a simple text request with the agents endpoint
    stream = agents_client.chat.completions.create(
        model="openai-gpt-4o-mini",
        messages=[{
            "role": "user",
            "content": "Hello! WHo is Amit?"
        }],
        extra_body = {"include_retrieval_info": True}
    )
    
    print(f"\nAgents endpoint response: {agents_response.choices[0].message.content}")

    for choice in response.choices:
         print(choice.message.content)
    
     response_dict = response.to_dict()

     print("\nFull retrieval object:")
     print(json.dumps(response_dict["retrieval"], indent=2))
    
except Exception as e:
    print(f"Error with agents endpoint: {e}")

from openai import OpenAI
from dotenv import load_dotenv
import os
import json
load_dotenv()

try:
    # Create a new client with the agents endpoint
    agents_client = OpenAI(
        base_url="https://rrp247s4dgv4xoexd2sk62yq.agents.do-ai.run/api/v1/",
        api_key=os.getenv("AJOT_AGENT_KEY")
    )
    
        
    # Try a simple text request with the agents endpoint
    stream = agents_client.chat.completions.create(
        model="openai-gpt-4o-mini",
        messages=[{
            "role": "user",
            "content": "Hello! WHo is Amit?"
        }],
        extra_body = {"include_retrieval_info": True},
        stream=True,
    )
    
    for event in stream:
        if event.choices[0].delta.content is not None:
            print(event.choices[0].delta.content, end='', flush=True)
    print()  # Add a newline at the end
    
except Exception as e:
    print(f"Error with agents endpoint: {e}")

• You can use the OpenAI SDK directly with DigitalOcean’s Serverless Inference and Agents.
• The only thing you need to change is the base_url—everything else stays the same.
• Use https://inference.do-ai.run/v1/ for general-purpose models like LLaMA 3, GPT-4o, Claude, etc.\
• Use your Agent’s URL (plus /api/v1) to connect to your own docs or knowledge base.
• Everything runs through .chat.completions.create()—no new methods to learn.
• You can enable streaming with stream=True, and get retrieval info with include_retrieval_info=True.

• What is Serverless Inference?: A simple overview of how Serverless Inference works and where it fits.
• How to Use Serverless Inference: Documentation for Serverless Inference
• List of Supported Models: Full breakdown of all models available (OpenAI, Claude, LLaMA, Mistral, etc.).
• Create and Configure a DigitalOcean Agent: Walkthrough for building agents that respond using your own knowledge base.
• Inference API Reference: Schema, endpoints, and everything under the hood.
• OpenAI Python SDK: The official SDK this entire guide is built on.

• Understand what a priority queue is and how it differs from regular queues
• Implement a basic priority queue using Python’s built-in heapq module
• Create thread-safe priority queues with the queue.PriorityQueue class
• Build both min-heap and max-heap priority queues through priority inversion
• Develop custom priority queue classes by implementing comparison methods
• Choose the right priority queue implementation for your specific use case
• Apply priority queues to real-world scenarios like process scheduling, task management, and resource allocation
• Optimize your applications by leveraging priority queues for ordered data processing
• Debug common issues when working with priority queues in Python
• Follow best practices for priority queue implementation and usage

Key Concepts

• PriorityQueue is a thread-safe implementation of a priority queue, ensuring safe access and modification in multi-threaded environments.
• The put method is used to add tasks to the priority queue, where the first argument is the priority and the second argument is the task itself.
• The get method retrieves the task with the highest priority from the queue.
• The task_done method is used to indicate that a task has been completed.
• The join method blocks until all tasks in the queue have been processed and completed.

• Python 3.7 or newer installed
• Familiarity with lists, functions, and classes.
• Optional: basic multithreading knowledge

What are some use cases and applications for priority queues?

• Operating Systems: Process scheduling where high-priority tasks need to be executed first
• Network Routers: Managing network traffic by prioritizing certain types of data packets
• Healthcare Systems: Organizing emergency room patients based on condition severity
• Task Management Software: Handling tasks based on urgency and importance
• Game Development: AI decision making and event scheduling
• Resource Management: Allocating limited resources to competing requests

Who Can Use Priority Queues?

1. Software Developers
   
   • Backend developers implementing job queues
   • Game developers managing game events
   • System programmers working on schedulers
2. Data Scientists
   
   • Implementing algorithms like Dijkstra’s shortest path
   • Managing computational tasks in order of importance
3. System Architects
   
   • Designing distributed systems
   • Building load balancers and request handlers
4. Business Applications
   
   • Customer service ticket systems
   • Project management tools
   • Inventory management systems

• Process items in a specific order based on importance
• Manage limited resources efficiently
• Handle real-time events that require immediate attention
• Implement algorithms that require ordered processing

import heapq

pq = []
# push
heapq.heappush(pq, (2, "code"))
heapq.heappush(pq, (1, "eat"))
heapq.heappush(pq, (3, "sleep"))

# pop – always smallest priority
priority, task = heapq.heappop(pq)
print(priority, task)            # 1 eat

Output
1 eat
2 code
3 sleep

Benefits of Using heapq

Limitations of Using heapq

Min-Heap

• The value of each node is less than or equal to the values of its children
• The root node contains the minimum value in the heap
• Used when you need to efficiently find/remove the smallest element
• Python’s heapq implements a min-heap

       1
     /   \
    3     2
   / \   /
  6   4 5

Max-Heap

• The value of each node is greater than or equal to the values of its children
• The root node contains the maximum value in the heap
• Used when you need to efficiently find/remove the largest element

       6
     /   \
    4     5
   / \   /
  1   3 2

• Inverting priorities (using negative values)
• Implementing a custom class with the __lt__ comparison method

1. How to Implement a Max-Heap using Inverting Priorities(using negative values)

import heapq

# Initialize an empty list to act as the heap
max_heap = []

# Push elements into the simulated max-heap by negating them
heapq.heappush(max_heap, -5)
heapq.heappush(max_heap, -1)
heapq.heappush(max_heap, -8)

# Pop the largest element (which was stored as the smallest negative value)
largest_element = -heapq.heappop(max_heap)

print(f"Largest element: {largest_element}")

Output
Largest element: 8

Benefits of Max-Heap using Negative Priorities

• Simple and straightforward implementation
• Works well with numeric values
• No custom class implementation required
• Maintains O(log n) time complexity for operations
• Memory efficient as it only stores the negated values

Drawbacks of Max-Heap using Negative Priorities

• Only works with numeric values
• May cause integer overflow for very large numbers
• Less readable code due to double negation
• Cannot directly view the actual values in the heap without negating them
• Not suitable for complex objects or non-numeric priorities.

2. How to Implement a Max-Heap with a Custom Class using __lt__?

class MaxHeap:
    def __init__(self):
        # Initialize an empty list to act as the heap
        self.heap = []

    def push(self, value):
        # Push elements into the simulated max-heap
        heapq.heappush(self.heap, value)

    def pop(self):
        # Pop the largest element from the heap
        return heapq.heappop(self.heap)

    def __lt__(self, other):
        # Compare two MaxHeap instances based on their heap contents
        return self.heap < other.heap

# Example usage
# Create two MaxHeap instances
heap1 = MaxHeap()
heap2 = MaxHeap()

# Push elements into the heaps
heap1.push(5)
heap1.push(1)
heap1.push(8)

heap2.push(3)
heap2.push(2)
heap2.push(9)

# Compare the heaps
print(heap1 < heap2)  # This will compare the heaps based on their contents

Output
True

Benefits of Max-Heap using Custom Class

• Allows for the use of non-numeric values or complex objects as priorities
• Enables direct comparison of objects without negation
• Provides a more readable and intuitive implementation
• Supports the use of custom comparison logic for objects

Drawbacks of Max-Heap using Custom Class

• Requires a custom class implementation
• May be less efficient for large datasets due to the overhead of object creation and comparison
• Can be more complex to implement and understand for beginners
• May not be suitable for scenarios where numeric values are sufficient and simplicity is preferred.

from queue import PriorityQueue
import threading, random, time

# Create a PriorityQueue instance
pq = PriorityQueue()

# Define a worker function that will process tasks from the priority queue
def worker():
    while True:
        # Get the task with the highest priority from the queue
        pri, job = pq.get()
        # Process the task
        print(f"Processing {job} (pri={pri})")
        # Indicate that the task is done
        pq.task_done()

# Start a daemon thread that will run the worker function
threading.Thread(target=worker, daemon=True).start()

# Add tasks to the priority queue with random priorities
for job in ["build", "test", "deploy"]:
    pq.put((random.randint(1, 10), job))

# Wait for all tasks to be processed
pq.join()

Output
Processing build (pri=1)
Processing test (pri=2)
Processing deploy (pri=3)

1. What is a priority queue in Python?

2. How do I implement a priority queue in Python?

import heapq

# Create a priority queue
pq = []

# Add elements to the priority queue
heapq.heappush(pq, (3, 'task3'))  # Priority 3
heapq.heappush(pq, (1, 'task1'))  # Priority 1
heapq.heappush(pq, (2, 'task2'))  # Priority 2

# Remove elements from the priority queue
while pq:
    priority, task = heapq.heappop(pq)
    print(f"Priority: {priority}, Task: {task}")

from queue import PriorityQueue

# Create a priority queue
pq = PriorityQueue()

# Add elements to the priority queue
pq.put((3, 'task3'))  # Priority 3
pq.put((1, 'task1'))  # Priority 1
pq.put((2, 'task2'))  # Priority 2

# Remove elements from the priority queue
while not pq.empty():
    priority, task = pq.get()
    print(f"Priority: {priority}, Task: {task}")

3. Is Python’s heapq a min-heap or max-heap?

• Inverting priorities (using negative values)
• Implementing a custom class with the __lt__ comparison method.

4. When should I use a priority queue?

• Task scheduling: Prioritize tasks based on their urgency or importance.
• Resource allocation: Allocate resources to tasks or processes based on their priority.
• Event handling: Handle events in the order of their priority, ensuring critical events are processed first.
• Job scheduling: Schedule jobs or tasks in a priority order to ensure efficient resource utilization.

5. When to use heapq?

• In single-threaded applications where performance is critical and priority queue operations are not concurrent.
• When manual synchronization and task completion management are feasible and acceptable.

6. When to use PriorityQueue?

• In multithreaded applications where thread safety, synchronization, and priority management are essential.
• When built-in synchronization, blocking operations, and automatic task completion management are necessary for efficient and safe concurrent access.

Next Steps

• JavaScript Binary Heaps: Learn about binary heaps in JavaScript.
• Python Multiprocessing Example: Understand how to use the multiprocessing module in Python.
• Python Tutorial: A comprehensive tutorial on Python for beginners.

• Understand what the GradientAI Platform is and how it can be used to build AI-powered applications, including its key features like serverless inference, agent routing, and knowledge bases
• Understand how to use the GradientAI Platform to build a travel app that generates personalized itineraries, provides flight information, and offers accommodation recommendations using AI
• Understand how to use the GradientAI Platform to build an intelligent chatbot that can handle both accommodation queries and general travel questions through specialized agent routing

How GradientAI is being used in Nomado

• Generating travel itineraries: Once you are done with visa research, Nomado helps you build a personalized travel itinerary based on your travel destination, number of days, and month of travel.
• Getting flight information: Nomado follows a journey in itself. After your visa is sorted and you have an itinerary, the next thing you want to do is book flights. This is where we are using the GradientAI platform to fetch flight details for us.
• Chat interface: Visa sorted, flights booked, itinerary ready. Now comes the final part, finding the right place to stay and understanding the culture, local tips, and what to expect when you arrive. This is where our chat interface steps in. It’s built to answer all your accommodation and travel questions.

const SECURE_AGENT_KEY = process.env.SECURE_AGENT_KEY
const AGENT_BASE_URL = "https://inference.do-ai.run/v1" //the inference endpoint


const client = hasRequiredEnvVars
  ? new OpenAI({
      apiKey: SECURE_AGENT_KEY,
      baseURL: AGENT_BASE_URL,
    })
  : null

Step 1: Your input (Browser)

• Destination: e.g Paris
• Duration: e.g 3 days
• Month: e.g June

Step 2: Next.js server action for itinerary generation

const prompt = `Your task is to generate a comprehensive travel plan for a ${duration}-day trip to ${destination} in ${visitMonth}. Make sure to bold the headings.
    
Please provide:
1. A ${duration}-day itinerary with day-by-day activities
2. A detailed packing list tailored to this destination in ${visitMonth} (considering the local weather and conditions)
3. Local customs and cultural tips
4. Must-try local foods
5. Transportation recommendations

Format your response in markdown with clear sections.`

Step 3: DigitalOcean GradientAI processing

• Loads the llama-3.1-8b-instruct model
• Runs the model with the prompt above
• Generates your complete travel plan
• Sends the result back

Step 1: Browser input for flight search

• From City: “New York”
• To City: “London”
• Departure Date: “2024-06-15”
• Trip Type: “round-trip” or “one-way”
• Return Date: “2024-06-22” (for round-trip)

Step 2: Next.js server action for flight search

const prompt = `You are a travel agent and your task is to show users flights along with flight numbers based on the source and destination they input.
Please provide flight information in the following format:
Outbound Flights (${fromCity} to ${toCity} on ${departureDate}):
Airline FlightNumber: Departing [Airport] at [Time], arriving [Airport] at [Time] (Flight Duration: [Duration], non-stop/with layover)
${tripType === "round-trip" ? `Return Flights (${toCity} to ${fromCity} on ${returnDate}):
Airline FlightNumber: Departing [Airport] at [Time], arriving [Airport] at [Time] (Flight Duration: [Duration], non-stop/with layover)` : ""}
For each flight, include:
- The type of flight (Boeing 737, Airbus A320, etc.)
- Airline name and flight number
- Airport codes
- Exact departure and arrival times
- Flight duration
- Layover information if applicable
- Direct booking links from Skyscanner, Kayak, or Expedia
Format your response in markdown with clear sections. Do NOT include any extra notes, disclaimers, or introductory text. Only output the flight details as described.`

Step 3: DigitalOcean GradientAI agent function routing

• Calls the deployed function (`flight-func/flight`) in the flight-info folder
• The function executes code that calls the Tripadvisor API with the user’s flight search parameters
• Returns real-time flight data (airlines, flight numbers, times, etc.)

Step 4: Response back to browser for flight search

const response = await client.chat.completions.create({
model: "Llama 3.3 Instruct",
messages: [
{
role: "system",
content: "You are an expert travel agent who specializes in finding specific flight information and providing direct booking links. Your responses should be practical and focused on helping travelers find and book their flights easily. Use real-time flight data and provide accurate information.",
},
{ role: "user", content: prompt },
],
temperature: 0.7,
max_tokens: 2000,
})
const content = response.choices[0]?.message?.content || "No response from AI"
return content

• Parent agents (Accommodation agent in this case) handle general conversation and route specific requests to specialized child agents
• Child agents (Local info agent)are optimized for specific domains or tasks

Step 1: Browser input for chat

• Accommodation Query: “Find me accommodation in Paris” OR
• General Travel Query: “What should I pack for Japan?”

Step 2: Parent accommodation agent & agent routing

• Receives the user query through the chatbot interface
• Analyzes the intent and content of the query
• Determines the appropriate routing based on query type:
  • Accommodation queries → Processes directly using the Nomad stays knowledge base
  • Travel/local info queries → Routes to the Local-info child agent with OpenAI 4o models
• For accommodation queries: Generates response using scraped data from Nomad stays
• For other queries: Delegates to specialized child agent

Step 3: Response processing

• Parent agent processes the query directly
• Searches through the Nomad stays knowledge base
• Generates accommodation recommendations

• Parent agent routes to Local-info child agent
• Child agent processes using OpenAI 4o models
• Generates travel tips, cultural information, or local advice
• Sends response back to parent agent

Step 4: Response back to browser for chat

• User receives specific, data-driven recommendations
• Response maintains conversational context through the parent agent

• Use serverless inference for tasks like generating text or summaries.
• Use function routing to plug in real-time APIs so your AI stays accurate with the latest data and is contextually aware.
• Use agent routing and knowledge bases to keep your answers consistent, especially if you have domain-specific content or multiple use cases.

• Get started with the GradientAI Platform - A comprehensive guide to help you start building AI applications on GradientAI Platform
• Deploy Serverless Functions - Learn how to deploy and manage scalable serverless functions without infrastructure overhead
• Build AI Agents with knowledge base web crawling - Tutorial on creating AI agents that can crawl websites and build knowledge bases for intelligent responses
• What’s new on GradientAI Platform - Latest features and improvements added to the GradientAI Platform
• Introducing DigitalOcean GradientAI - Announcement and overview of DigitalOcean’s new AI development platform
• GradientAI Platform Generally Available - Details about GradientAI Platform’s general availability release and enterprise-ready features