Build and deploy your
sustainable and open
AI applications

Green and private full-stack AI. 
Ready to be used and bringing real advantages.

Try Now
Contact Us

Green Mood

AI needs enormous computing power compared with ordinary workloads. Regolo.ai is your InferenceAAS for LLMs and other models that cares for the planet. Regolo runs on green hosting, thanks to the green energy used for powering its data centers and the sustainable processes that govern their infrastructures. Our monitoring of the token/WATT allows us to maintain control over its carbon emissions.

Free and Open for you. Private for your business

Our AI solution is European, open and transparent. We don’t like lock-in. 
We like innovation and freedom. Our models are multiple and available for everybody. Once trained, your data will keep on being your data.

Serverless AI on GPUs

Run generative AI parallel tasks taking advantage of our fully integrated Kubernetes AI infrastructure. Try the best power and extend your infrastructure easily and rapidly with a pay as you go model and a complete management of the GPU cloud computing environment. With no execution time limitations.

Compliance and data governance

Guarantee your data the best protection. Train and protect quality data for quality applications. Protect them from being used for something else. Regolo.ai runs on European data centers based in Italy and offers GDPR compliance and a special attention to your privacy.

curl -i --location $ENDPOINT \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer ${REGOLO_TOKEN}" \
     --data '{
               "model": "$MODEL",
               "messages": [{
                   "role": "user",
                   "content": "Tell me about Rome in a concise manner"
               }],
               "stream": "True"
             }'
const fetch = require('node-fetch');

const url = process.env.ENDPOINT;
const token = process.env.REGOLO_TOKEN;

const data = {
	    model: "$MODEL",
	    messages: [{ role: "user", content: "Tell me about Rome in a concise manner" }]
};

fetch(url, {
	    method: 'POST',
	    headers: {
		            'Content-Type': 'application/json',
		            'Accept': 'application/json',
		            'Authorization': `Bearer ${token}`
		        },
	    body: JSON.stringify(data)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
import requests

url = "$ENDPOINT"
headers = {
            "Content-Type": "application/json",
                "Accept": "application/json",
                    "Authorization": f"Bearer {os.getenv('REGOLO_TOKEN')}"
                    }
data = {
            "model": "$MODEL",
                "messages": [{"role": "user", "content": "Tell me about Rome in a concise manner"}]
                }

response = requests.post(url, headers=headers, json=data)
print(response.json())
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

func main() {
    url := os.Getenv("ENDPOINT")
    token := os.Getenv("REGOLO_TOKEN")

    data := map[string]interface{}{
        "model": "$MODEL",
        "messages": []map[string]string{
            {"role": "user", "content": "Tell me about Rome in a concise manner"},
        },
    }

    jsonData, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Authorization", "Bearer "+token)

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}
curl -X POST --location $ENDPOINT \
	--header 'Content-Type: application/json' \
	--header "Authorization: Bearer ${REGOLO_TOKEN}" \
	--data '{ "data": ["Cat playing the piano"] }' \
	$ENDPOINT
const fetch = require('node-fetch');

const url = process.env.ENDPOINT;
const token = process.env.REGOLO_TOKEN;

const data = { data: ["Cat playing the piano"] };

fetch(url, {
		method: 'POST',
			headers: {
						'Content-Type': 'application/json',
								'Authorization': `Bearer ${token}`
									},
				body: JSON.stringify(data)
				})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
import requests
import os

url = os.getenv('ENDPOINT')
headers = {
			"Content-Type": "application/json",
				"Authorization": f"Bearer {os.getenv('REGOLO_TOKEN')}"
				}
data = { "data": ["Cat playing the piano"] }

response = requests.post(url, headers=headers, json=data)
print(response.json())
import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	url := os.Getenv("ENDPOINT")
	token := os.Getenv("REGOLO_TOKEN")

	data := map[string]interface{}{
		"data": []string{"Cat playing the piano"},
	}

	jsonData, _ := json.Marshal(data)
	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+token)

	client := &http.Client{}
	resp, _ := client.Do(req)
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Println(result)
}
curl https://api.regolo.ai/v1/models/whisper-large-v3/transcriptions \
	-H "Authorization: Bearer $REGOLOAI_API_KEY" \
	-H "Content-Type: multipart/form-data" \
	-F model="$MODEL" \
	-F file="@file.mp3"
const fetch = require('node-fetch');
const fs = require('fs');
const FormData = require('form-data');

const url = "https://api.regolo.ai/v1/models/whisper-large-v3/transcriptions";
const apiKey = "$REGOLOAI_API_KEY";

const form = new FormData();
form.append("model", "$MODEL");
form.append("file", fs.createReadStream("file.mp3"));

fetch(url, {
		method: 'POST',
		headers: { "Authorization": `Bearer ${apiKey}`, ...form.getHeaders() },
		body: form
})
	.then(res => res.json())
	.then(data => console.log(data))
	.catch(err => console.error('Error:', err));
import requests

url = "https://api.regolo.ai/v1/models/whisper-large-v3/transcriptions"
headers = {"Authorization": "Bearer $REGOLOAI_API_KEY"}

files = {
			"model": (None, "$MODEL"),
				"file": ("file.mp3", open("file.mp3", "rb"))
				}

response = requests.post(url, headers=headers, files=files)
print(response.json())
package main

import (
	"bytes"
	"fmt"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	url := "https://api.regolo.ai/v1/models/whisper-large-v3/transcriptions"
	apiKey := "$REGOLOAI_API_KEY"

	file, err := os.Open("file.mp3")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	var b bytes.Buffer
	writer := multipart.NewWriter(&b)
	writer.WriteField("model", "$MODEL")
	part, err := writer.CreateFormFile("file", "file.mp3")
	if err != nil {
		panic(err)
	}
	_, err = io.Copy(part, file)
	if err != nil {
		panic(err)
	}
	writer.Close()

	req, err := http.NewRequest("POST", url, &b)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", writer.FormDataContentType())

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var resBody bytes.Buffer
	resBody.ReadFrom(resp.Body)
	fmt.Println(resBody.String())
}
curl -i --location $ENDPOINT \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer ${REGOLO_TOKEN}" \
     --data '{
               "model": "$MODEL",
               "input": "Tell me about Rome in a concise manner"
               }'
            
const fetch = require('node-fetch');

const url = process.env.ENDPOINT;
const token = process.env.REGOLO_TOKEN;

const data = {
	    model: "$MODEL",
	    input: "Tell me about Rome in a concise manner"
};

fetch(url, {
	    method: 'POST',
	    headers: {
		            'Content-Type': 'application/json',
		            'Accept': 'application/json',
		            'Authorization': `Bearer ${token}`
		        },
	    body: JSON.stringify(data)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
import requests

url = "$ENDPOINT"
headers = {
            "Content-Type": "application/json",
                "Accept": "application/json",
                    "Authorization": f"Bearer {os.getenv('REGOLO_TOKEN')}"
                    }
data = {
            "model": "$MODEL",
            "input": "Tell me about Rome in a concise manner"
        }

response = requests.post(url, headers=headers, json=data)
print(response.json())
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

func main() {
    url := os.Getenv("ENDPOINT")
    token := os.Getenv("REGOLO_TOKEN")

    data := map[string]interface{}{
        "model": "$MODEL",
        "input": "Tell me about Rome in a concise manner"
        },
    }

    jsonData, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Authorization", "Bearer "+token)

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}

Guaranteed performance and the safety of your confidential data and proprietary models.

Are you a developer, a data scientist, or part of a developers team?

Regolo.ai gives you the best quality private full-stack AI guaranteeing you the best performance and the safeguard of your projects. Regolo.ai is your sustainable InferenceAsAService ready to support your AI and ML development with close attention to your data.

Try Now
Contact Us

Contact us for more information

We will get back to you as soon as possible.

Powered by Seeweb Logo
Privacy & Cookie | General Conditions

Powered by

Privacy & Cookie | General Conditions

Torna in alto