Fuse AI Services API

fetch('https://api.fuseais.com/health', {
  method: 'GET',
  headers: {
    'X-API-Key': 'YOUR_API_KEY'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

import requests

url = "https://api.fuseais.com/health"
headers = {
    "X-API-Key": "YOUR_API_KEY"
}

response = requests.get(url, headers=headers)
print(response.json())

    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    import java.time.Duration;
    
    import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    public class HealthCheckExample {
        public static void main(String[] args) {
            try {
                // Create HTTP client
                HttpClient client = HttpClient.newHttpClient();
                
                // Build the request
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.fuseais.com/health"))
                    .header("X-API-Key", "YOUR_API_KEY")
                    .timeout(Duration.ofSeconds(10))
                    .GET()
                    .build();
                    
                // Send the request and get the response
                HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
                
                // Check response status
                if (response.statusCode() != 200) {
                    System.out.println("Health check failed: HTTP status code " + response.statusCode());
                    return;
                }
                
                // Parse the JSON response
                ObjectMapper mapper = new ObjectMapper();
                JsonNode healthData = mapper.readTree(response.body());
                
                // Extract and display health information
                String status = healthData.get("status").asText();
                String version = healthData.get("version").asText();
                
                System.out.println("Health Check Result:");
                System.out.println("Status: " + status);
                System.out.println("Version: " + version);
                
                // Also show available models if present
                if (healthData.has("available_models")) {
                    System.out.println("Available Models:");
                    healthData.get("available_models").forEach(model -> 
                        System.out.println("- " + model.asText()));
                }
                
            } catch (Exception e) {
                System.out.println("Error performing health check: " + e.getMessage());
            }
        }
    }
                        

fetch('https://api.fuseais.com/api/v1/admin/token', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            username: 'admin',
            password: 'secure_password'
        })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('Authentication failed: ' + response.status);
        }
        return response.json();
    })
    .then(data => {
        // Store the token for future API calls
        localStorage.setItem('api_token', data.access_token);
        console.log('Authentication successful');
    })
    .catch(error => console.error('Error:', error));

import requests
import json

url = "https://api.fuseais.com/api/v1/admin/token"
headers = {
    "Content-Type": "application/json"
}
payload = {
    "username": "admin",
    "password": "secure_password"
}

try:
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()  # Raise an exception for 4XX/5XX responses
    
    data = response.json()
    
    # Store the token for future API calls
    token = data["access_token"]
    print("Authentication successful")
except requests.exceptions.HTTPError as err:
    if response.status_code == 401:
        print("Authentication failed: Invalid credentials")
    else:
        print(f"HTTP Error: {err}")
except Exception as err:
    print(f"Error: {err}")

import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    import java.util.Map;
    
    import com.fasterxml.jackson.databind.JsonNode;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    public class GetAuthTokenExample {
        public static void main(String[] args) {
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                
                Map credentials = Map.of(
                    "username", "admin", 
                    "password", "secure_password"
                );
                
                String requestBody = objectMapper.writeValueAsString(credentials);
                
                HttpClient client = HttpClient.newHttpClient();
                
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.fuseais.com/api/v1/admin/token"))
                    .header("Content-Type", "application/json")
                    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                    .build();
                    
                HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
                
                int statusCode = response.statusCode();
                if (statusCode == 401) {
                    System.out.println("Authentication failed: Invalid credentials");
                    return;
                } else if (statusCode != 200) {
                    throw new RuntimeException("Failed: HTTP error code: " + statusCode);
                }
                
                JsonNode jsonResponse = objectMapper.readTree(response.body());
                
                String accessToken = jsonResponse.get("access_token").asText();
                String tokenType = jsonResponse.get("token_type").asText();
                
                System.out.println("Authentication successful");
                System.out.println("Token: " + accessToken);
                System.out.println("Token type: " + tokenType);
                
            } catch (Exception e) {
                System.err.println("Error during authentication: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }
                    

import requests

url = "https://api.fuseais.com/api/v1/admin/users/me"
headers = {"X-API-Key": "YOUR_API_KEY"}

response = requests.get(url, headers=headers)
print(response.json())

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class GetCurrentUserExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/admin/users/me"))
            .header("X-API-Key", "YOUR_API_KEY")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/admin/users"
headers = {"X-API-Key": "YOUR_ADMIN_API_KEY"}

response = requests.get(url, headers=headers)
for user in response.json():
    print(user["username"], user["role"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ListUsersExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/admin/users"))
            .header("X-API-Key", "YOUR_ADMIN_API_KEY")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/admin/rate-limits"
headers = {"X-API-Key": "YOUR_ADMIN_API_KEY"}

response = requests.get(url, headers=headers)
data = response.json()
print(f"Window: {data['window_size']}s, Max: {data['max_requests']} requests")
for client_id, count in data["rate_limits"].items():
    print(f"  {client_id}: {count} requests")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class GetRateLimitsExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/admin/rate-limits"))
            .header("X-API-Key", "YOUR_ADMIN_API_KEY")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/admin/api-keys"
headers = {"X-API-Key": "YOUR_ADMIN_API_KEY", "Content-Type": "application/json"}
payload = {
    "user_id": "alice",
    "customer_id": "cust_abc123",
    "scope": "read:write"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print("New API key:", data["api_key"])  # save this — shown only once

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class CreateApiKeyExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"user_id\":\"alice\",\"customer_id\":\"cust_abc123\",\"scope\":\"read:write\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/admin/api-keys"))
            .header("X-API-Key", "YOUR_ADMIN_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

key_id = "ki_abc123"
url = f"https://api.fuseais.com/api/v1/admin/api-keys/{key_id}"
headers = {"X-API-Key": "YOUR_ADMIN_API_KEY"}

response = requests.delete(url, headers=headers)
print(response.json())  # {"status": "success"}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class RevokeApiKeyExample {
    public static void main(String[] args) throws Exception {
        String keyId = "ki_abc123";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/admin/api-keys/" + keyId))
            .header("X-API-Key", "YOUR_ADMIN_API_KEY")
            .DELETE()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

fetch('https://api.fuseais.com/api/v1/llm/query', {
                          method: 'POST',
                          headers: {
                            'X-API-Key': 'YOUR_API_KEY',
                            'Content-Type': 'application/json'
                          },
                          body: JSON.stringify({
                            query: 'What is the capital of France?',
                            user_id: 'user123',
                            model: 'claude'
                          })
                        })
                        .then(response => {
                          if (!response.ok) {
                            throw new Error('API request failed: ' + response.status);
                          }
                          return response.json();
                        })
                        .then(data => {
                          console.log('Response:', data.response);
                          console.log('Tokens used:', data.tokens_used);
                          console.log('Tokens remaining:', data.tokens_remaining);
                        })
                        .catch(error => console.error('Error:', error));

import requests
                        import json
                        
                        url = "https://api.fuseais.com/api/v1/llm/query"
                        headers = {
                            "X-API-Key": "YOUR_API_KEY",
                            "Content-Type": "application/json"
                        }
                        payload = {
                            "query": "What is the capital of France?",
                            "user_id": "user123",
                            "model": "claude"
                        }
                        
                        try:
                            response = requests.post(url, headers=headers, json=payload)
                            response.raise_for_status()  # Raise exception for 4XX/5XX responses
                            
                            data = response.json()
                            print("Response:", data["response"])
                            print("Model used:", data["model_used"])
                            print("Tokens used:", data["tokens_used"])
                            print("Tokens remaining:", data["tokens_remaining"])
                            
                        except requests.exceptions.HTTPError as err:
                            print(f"HTTP Error: {err}")
                            print(f"Response: {response.text}")
                        except Exception as err:
                            print(f"Error: {err}")

import java.net.URI;
                        import java.net.http.HttpClient;
                        import java.net.http.HttpRequest;
                        import java.net.http.HttpResponse;
                        import java.util.Map;
                        
                        import com.fasterxml.jackson.databind.JsonNode;
                        import com.fasterxml.jackson.databind.ObjectMapper;
                        
                        public class QueryLLMExample {
                            public static void main(String[] args) {
                                try {
                                    // Create request body using Map
                                    Map<String, String> requestData = Map.of(
                                        "query", "What is the capital of France?",
                                        "user_id", "user123",
                                        "model", "claude"
                                    );
                        
                                    // Convert to JSON and send request
                                    ObjectMapper objectMapper = new ObjectMapper();
                                    String requestBody = objectMapper.writeValueAsString(requestData);
                        
                                    HttpClient client = HttpClient.newHttpClient();
                                    HttpRequest request = HttpRequest.newBuilder()
                                        .uri(URI.create("https://api.fuseais.com/api/v1/llm/query"))
                                        .header("X-API-Key", "YOUR_API_KEY")
                                        .header("Content-Type", "application/json")
                                        .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                                        .build();
                        
                                    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
                        
                                    // Check response status
                                    if (response.statusCode() != 200) {
                                        System.out.println("Error: HTTP status code " + response.statusCode());
                                        return;
                                    }
                        
                                    // Parse response
                                    JsonNode node = objectMapper.readTree(response.body());
                                    String llmResponse = node.get("response").asText();
                                    int tokensUsed = node.get("tokens_used").asInt();
                                    int tokensRemaining = node.get("tokens_remaining").asInt();
                                    
                                    System.out.println("Response: " + llmResponse);
                                    System.out.println("Tokens used: " + tokensUsed);
                                    System.out.println("Tokens remaining: " + tokensRemaining);
                                    
                                } catch (Exception e) {
                                    System.out.println("Error: " + e.getMessage());
                                }
                            }
                        }

import requests

url = "https://api.fuseais.com/api/v1/file/upload/multiple"
headers = {"X-API-Key": "YOUR_API_KEY"}
files = [
    ("files", open("doc1.txt", "rb")),
    ("files", open("doc2.txt", "rb")),
    ("files", open("image.png", "rb")),
]

response = requests.post(url, headers=headers, files=files)
data = response.json()
print(f"Session: {data['session_id']}")
print(f"Uploaded: {data['files']}")

// Use a multipart HTTP client library such as OkHttp for multipart uploads.
// Example shown with OkHttp:
// OkHttpClient client = new OkHttpClient();
// MultipartBody body = new MultipartBody.Builder()
//     .setType(MultipartBody.FORM)
//     .addFormDataPart("files", "doc1.txt", RequestBody.create(new File("doc1.txt"), MediaType.parse("text/plain")))
//     .addFormDataPart("files", "doc2.txt", RequestBody.create(new File("doc2.txt"), MediaType.parse("text/plain")))
//     .build();
// Request request = new Request.Builder()
//     .url("https://api.fuseais.com/api/v1/file/upload/multiple")
//     .header("X-API-Key", "YOUR_API_KEY")
//     .post(body)
//     .build();
// Response response = client.newCall(request).execute();
// System.out.println(response.body().string());

import requests

# Step 1: Get presigned URLs
url = "https://api.fuseais.com/api/v1/file/upload/presigned"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = [{"file_name": "report.pdf", "content_type": "application/pdf"}]

resp = requests.post(url, json=payload, headers=headers)
data = resp.json()

# Step 2: Upload directly to S3
for item in data["urls"]:
    with open(item["file_name"], "rb") as f:
        requests.put(item["upload_url"], data=f,
                     headers={"Content-Type": "application/pdf"})

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;

public class PresignedUploadExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        // Step 1: Get presigned URL
        String body = "[{\"file_name\":\"report.pdf\",\"content_type\":\"application/pdf\"}]";
        HttpRequest req1 = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/upload/presigned"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> resp1 = client.send(req1, HttpResponse.BodyHandlers.ofString());
        System.out.println(resp1.body());

        // Step 2: PUT file to the presigned URL (parse upload_url from resp1)
    }
}

import requests

file_id = "tmp/cust_abc123/session123/report.pdf"
url = f"https://api.fuseais.com/api/v1/file/{requests.utils.quote(file_id, safe='')}"
headers = {"X-API-Key": "YOUR_API_KEY"}

response = requests.get(url, headers=headers)
with open("report.pdf", "wb") as f:
    f.write(response.content)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;

public class DownloadFileExample {
    public static void main(String[] args) throws Exception {
        String fileId = "tmp%2Fcust_abc123%2Fsession123%2Freport.pdf";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/" + fileId))
            .header("X-API-Key", "YOUR_API_KEY")
            .GET()
            .build();
        HttpResponse<Path> response = client.send(request,
            HttpResponse.BodyHandlers.ofFile(Path.of("report.pdf")));
        System.out.println("Saved to: " + response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/file/process"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {"file_id": "tmp/cust_abc123/session123/report.txt"}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Tokens: {data['tokens']}")
print(data["processed_content"][:200])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ProcessFileExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"file_id\":\"tmp/cust_abc123/session123/report.txt\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/process"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/file/pdf/process"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {"file_id": "tmp/cust_abc123/session123/contract.pdf"}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Pages: {data['page_count']}")
print(data["extracted_text"][:500])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ProcessPdfExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"file_id\":\"tmp/cust_abc123/session123/contract.pdf\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/pdf/process"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/file/audio/transcribe"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "file_id": "tmp/cust_abc123/session123/meeting.mp3",
    "language": "en-US"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Duration: {data['duration_seconds']}s, Confidence: {data['confidence']}")
print(data["transcription"][:300])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class TranscribeAudioExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"file_id\":\"tmp/cust_abc123/session123/meeting.mp3\",\"language\":\"en-US\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/audio/transcribe"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/file/textract/form"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {"file_id": "tmp/cust_abc123/session123/w2_form.pdf", "form_type": "w2"}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
for field, value in data["form_data"].items():
    print(f"{field}: {value}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class TextractFormExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"file_id\":\"tmp/cust_abc123/session123/w2_form.pdf\",\"form_type\":\"w2\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/textract/form"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/file/textract/text"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {"file_id": "tmp/cust_abc123/session123/scanned_doc.pdf"}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Pages: {data['page_count']}, Confidence: {data['confidence']}")
print(data["extracted_text"][:500])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class TextractTextExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"file_id\":\"tmp/cust_abc123/session123/scanned_doc.pdf\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/file/textract/text"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/file/id/verify"
headers = {"X-API-Key": "YOUR_API_KEY"}

with open("drivers_license.jpg", "rb") as f:
    response = requests.post(url, headers=headers, files={"id_image": f})

data = response.json()
print(f"Valid: {data['is_valid']}, Type: {data['id_type']}")
print(data["verification_details"])

// Use OkHttp or similar library for multipart file uploads.
// OkHttpClient client = new OkHttpClient();
// RequestBody fileBody = RequestBody.create(new File("drivers_license.jpg"),
//     MediaType.parse("image/jpeg"));
// MultipartBody body = new MultipartBody.Builder()
//     .setType(MultipartBody.FORM)
//     .addFormDataPart("id_image", "drivers_license.jpg", fileBody)
//     .build();
// Request request = new Request.Builder()
//     .url("https://api.fuseais.com/api/v1/file/id/verify")
//     .header("X-API-Key", "YOUR_API_KEY")
//     .post(body)
//     .build();

import requests

url = "https://api.fuseais.com/api/v1/llm/summarize"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "text": "The quarterly earnings report shows significant growth...",
    "user_id": "user123",
    "max_length": 300,
    "format": "bullets"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(data["summary"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class SummarizeExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"text\":\"The quarterly earnings report...\",\"user_id\":\"user123\",\"max_length\":300,\"format\":\"bullets\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/llm/summarize"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

format_type = "json"  # json | csv | html | txt
url = f"https://api.fuseais.com/api/v1/llm/format/{format_type}"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {"content": "Name: Alice Smith, Age: 34, Department: Engineering"}

response = requests.post(url, json=payload, headers=headers)
print(response.json()["result"])

import requests

url = "https://api.fuseais.com/api/v1/llm/agent/execute"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "user_id": "user123",
    "agent_id": "research-agent",
    "input": "Summarize the latest SEC filings for ACME Corp and flag any risks."
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Steps taken: {data['steps_taken']}")
print(data["result"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AgentExecuteExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"user_id\":\"user123\",\"agent_id\":\"research-agent\","
            + "\"input\":\"Summarize the latest SEC filings for ACME Corp.\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/llm/agent/execute"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/llm/feedback"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "request_id": "550e8400-e29b-41d4-a716-446655440000",
    "user_id": "user123",
    "feedback": "positive",
    "comments": "Very helpful response."
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())  # {"status": "success"}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class SubmitFeedbackExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"request_id\":\"550e8400-e29b-41d4-a716-446655440000\","
            + "\"user_id\":\"user123\",\"feedback\":\"positive\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/llm/feedback"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/tools/web-search"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "YOUR_API_KEY"
}

payload = {
    "query": "Python FastAPI tutorials",
    "num_results": 5,
    "safe_search": "moderate"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

if data["status"] == "success":
    print(f"Found {data['total_results']} results in {data['search_time']}s")
    for result in data["results"]:
        print(f"\n{result['title']}")
        print(f"  URL: {result['url']}")
        print(f"  {result['snippet']}")
else:
    print(f"Search failed: {data}")

# Using search operators
payload_with_operator = {
    "query": "site:sec.gov 10-K filing filetype:pdf",
    "num_results": 5
}
response = requests.post(url, json=payload_with_operator, headers=headers)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.HashMap;

public class WebSearchExample {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            ObjectMapper objectMapper = new ObjectMapper();

            // Build request payload
            Map<String, Object> payload = new HashMap<>();
            payload.put("query", "Python FastAPI tutorials");
            payload.put("num_results", 5);
            payload.put("safe_search", "moderate");

            String requestBody = objectMapper.writeValueAsString(payload);

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.fuseais.com/api/v1/tools/web-search"))
                .header("Content-Type", "application/json")
                .header("X-API-Key", "YOUR_API_KEY")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 200) {
                JsonNode jsonResponse = objectMapper.readTree(response.body());

                String status = jsonResponse.get("status").asText();
                if ("success".equals(status)) {
                    int totalResults = jsonResponse.get("total_results").asInt();
                    double searchTime = jsonResponse.get("search_time").asDouble();

                    System.out.println("Found " + totalResults + " results in " +
                        searchTime + "s");

                    JsonNode results = jsonResponse.get("results");
                    for (JsonNode result : results) {
                        System.out.println("\n" + result.get("title").asText());
                        System.out.println("  URL: " + result.get("url").asText());
                        System.out.println("  " + result.get("snippet").asText());
                    }
                }
            } else {
                System.out.println("Search failed: HTTP " + response.statusCode());
            }

        } catch (Exception e) {
            System.err.println("Error performing search: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import requests

url = "https://api.fuseais.com/api/v1/tools/sms/send"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "YOUR_API_KEY"
}

payload = {
    "user_id": "user123",
    "to_number": "+15551234567",
    "message": "Hello from FuseAIs API!",
    "from_number": "+18551234567",
    "account_sid": "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "auth_token": "your_auth_token_here"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

if data["status"] == "success":
    print(f"SMS sent successfully!")
    print(f"Message SID: {data['message_sid']}")
    print(f"Status: {data['status_detail']}")
else:
    print(f"SMS failed: {data}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.HashMap;

public class SMSSendExample {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            ObjectMapper objectMapper = new ObjectMapper();

            // Build request payload
            Map<String, Object> payload = new HashMap<>();
            payload.put("user_id", "user123");
            payload.put("to_number", "+15551234567");
            payload.put("message", "Hello from FuseAIs API!");
            payload.put("from_number", "+18551234567");
            payload.put("account_sid", "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
            payload.put("auth_token", "your_auth_token_here");

            String requestBody = objectMapper.writeValueAsString(payload);

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.fuseais.com/api/v1/tools/sms/send"))
                .header("Content-Type", "application/json")
                .header("X-API-Key", "YOUR_API_KEY")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 200) {
                JsonNode jsonResponse = objectMapper.readTree(response.body());

                String status = jsonResponse.get("status").asText();
                if ("success".equals(status)) {
                    System.out.println("SMS sent successfully!");
                    System.out.println("Message SID: " +
                        jsonResponse.get("message_sid").asText());
                    System.out.println("Status: " +
                        jsonResponse.get("status_detail").asText());
                }
            } else {
                System.out.println("SMS failed: HTTP " + response.statusCode());
            }

        } catch (Exception e) {
            System.err.println("Error sending SMS: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import requests

url = "https://api.fuseais.com/api/v1/tools/email/send"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "YOUR_API_KEY"
}

payload = {
    "user_id": "user123",
    "access_token": "ya29.a0AfH6SMBx...",  # Gmail OAuth token
    "to_email": "recipient@example.com",
    "subject": "Hello from FuseAIs",
    "body": "This is a test email.",
    "html_body": "<h1>Hello</h1><p>Test email</p>"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

if data["status"] == "success":
    print(f"Email sent! Message ID: {data['message_id']}")
    print(f"Thread ID: {data['thread_id']}")

import requests

url = "https://api.fuseais.com/api/v1/tools/slack/send"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "YOUR_API_KEY"
}

# Method 1: Using Webhook
payload_webhook = {
    "user_id": "user123",
    "message": "Hello from FuseAIs!",
    "webhook_url": "https://hooks.slack.com/services/T.../B.../xxx",
    "username": "FuseAIs Bot",
    "icon_emoji": ":rocket:"
}

# Method 2: Using Bot Token
payload_bot = {
    "user_id": "user123",
    "message": "Hello team!",
    "bot_token": "xoxb-your-bot-token",
    "channel": "#general"
}

response = requests.post(url, json=payload_webhook, headers=headers)
data = response.json()

if data["status"] == "success":
    print(f"Message sent via {data['method']}")
else:
    print(f"Failed: {data}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.HashMap;

public class SlackSendExample {
    public static void main(String[] args) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            ObjectMapper objectMapper = new ObjectMapper();

            // Using Webhook method
            Map<String, Object> payload = new HashMap<>();
            payload.put("user_id", "user123");
            payload.put("message", "Hello from FuseAIs!");
            payload.put("webhook_url", "https://hooks.slack.com/services/T.../B.../xxx");

            String requestBody = objectMapper.writeValueAsString(payload);

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.fuseais.com/api/v1/tools/slack/send"))
                .header("Content-Type", "application/json")
                .header("X-API-Key", "YOUR_API_KEY")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 200) {
                JsonNode jsonResponse = objectMapper.readTree(response.body());
                System.out.println("Message sent via: " +
                    jsonResponse.get("method").asText());
            }

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import requests

url = "https://api.fuseais.com/api/v1/vectordb/documents"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "text": "Quarterly revenue increased 18% year-over-year.",
    "collection_name": "financial-docs",
    "metadata": {"source": "q1-2026-earnings.pdf"}
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class VectorUpsertExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"text\":\"Quarterly revenue increased 18%.\","
            + "\"collection_name\":\"financial-docs\","
            + "\"metadata\":{\"source\":\"q1-2026-earnings.pdf\"}}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/vectordb/documents"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/vectordb/query"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "query": "What was the revenue growth last quarter?",
    "collection_name": "financial-docs",
    "top_k": 5
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
for r in data["results"]:
    print(f"[{r['score']:.2f}] {r['text'][:100]}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class VectorQueryExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"query\":\"What was the revenue growth last quarter?\","
            + "\"collection_name\":\"financial-docs\",\"top_k\":5}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/vectordb/query"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/code/document"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "code": "def add(a, b):\n    return a + b",
    "language": "python",
    "include_examples": True
}

response = requests.post(url, json=payload, headers=headers)
print(response.json()["result"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class DocumentCodeExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"code\":\"def add(a, b):\\n    return a + b\","
            + "\"language\":\"python\",\"include_examples\":true}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/code/document"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/code/audit"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "code": "def process_data(user_input):\n    exec(user_input)",
    "language": "python",
    "audit_type": "security"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(data["result"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AuditCodeExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"code\":\"def process_data(user_input):\\n    exec(user_input)\","
            + "\"language\":\"python\",\"audit_type\":\"security\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/code/audit"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/code/validate"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "code": "def hello_world():\n    print('Hello, world!')",
    "language": "python",
    "user_id": "user123",
    "validation_type": "syntax"
}

response = requests.post(url, json=payload, headers=headers)
print(response.json()["result"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ValidateCodeExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"code\":\"def hello_world():\\n    print('Hello!')\","
            + "\"language\":\"python\",\"user_id\":\"user123\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/code/validate"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

{
  "status": "error",
  "output": "",
  "error": {
    "error_type": "NameError",
    "message": "name 'undefined_var' is not defined",
    "line_number": 3,
    "code_context": {"3": "print(undefined_var)"},
    "traceback": "Traceback (most recent call last):\n  ..."
  },
  "stats": {
    "execution_time_ms": 1.2,
    "output_size_bytes": 0,
    "had_errors": true
  },
  "output_files": []
}

{
  "status": "error",
  "output": "",
  "error": {
    "error_type": "PolicyViolation",
    "message": "Use of 'exec()' is not permitted in sandboxed execution"
  },
  "stats": {},
  "output_files": []
}

const response = await fetch('https://api.fuseais.com/api/v1/code/execute', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    code: "import pandas as pd\ndf = pd.DataFrame({'a': [1,2,3]})\nprint(df.describe())",
    timeout: 30
  })
});

const result = await response.json();
console.log(result.output);

// If the code generated files:
if (result.output_files?.length) {
  result.output_files.forEach(f =>
    console.log(`${f.name}: ${f.url}`)
  );
}

import requests

url = "https://api.fuseais.com/api/v1/code/execute"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

payload = {
    "code": "import pandas as pd\ndf = pd.DataFrame({'a': [1,2,3]})\nprint(df.describe())",
    "timeout": 30
}

response = requests.post(url, json=payload, headers=headers)
result = response.json()

print(result["output"])
print(f"Executed in {result['stats']['execution_time_ms']}ms")

import requests

url = "https://api.fuseais.com/api/v1/code/convert"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "code": "function add(a, b) { return a + b; }",
    "source_language": "javascript",
    "target_language": "python"
}

response = requests.post(url, json=payload, headers=headers)
print(response.json()["result"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ConvertCodeExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"code\":\"function add(a, b) { return a + b; }\","
            + "\"source_language\":\"javascript\",\"target_language\":\"python\"}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/code/convert"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/data/profile"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "user_id": "user123",
    "data": [{"name": "Alice", "age": 34}, {"name": "Bob", "age": None}]
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Rows: {data['profile']['row_count']}")
for rec in data["recommendations"]:
    print(f"  - {rec}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ProfileDataExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"user_id\":\"user123\","
            + "\"data\":[{\"name\":\"Alice\",\"age\":34},{\"name\":\"Bob\",\"age\":null}]}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/data/profile"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/data/density"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "user_id": "user123",
    "data": [{"col1": 1, "col2": None}, {"col1": 2, "col2": 5}],
    "threshold": 0.6
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Overall density: {data['density_analysis']['overall_density']}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class DataDensityExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"user_id\":\"user123\","
            + "\"data\":[{\"col1\":1,\"col2\":null},{\"col1\":2,\"col2\":5}],"
            + "\"threshold\":0.6}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/data/density"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/data/deduplicate"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "user_id": "user123",
    "data": [
        {"id": "r1", "name": "Alice Smith"},
        {"id": "r2", "name": "Alice  Smith"}
    ],
    "method": "fuzzy",
    "threshold": 0.9,
    "return_duplicates": True
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Duplicates found: {data['duplicate_count']}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class DeduplicateDataExample {
    public static void main(String[] args) throws Exception {
        String body = "{\"user_id\":\"user123\","
            + "\"data\":[{\"id\":\"r1\",\"name\":\"Alice Smith\"},{\"id\":\"r2\",\"name\":\"Alice  Smith\"}],"
            + "\"method\":\"fuzzy\",\"threshold\":0.9}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/data/deduplicate"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/data/join"
headers = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
payload = {
    "user_id": "user123",
    "datasets": [
        {"id": "ds1", "source": "crm", "format": "json",
         "content": [{"customer_id": "C1", "name": "Alice"}]},
        {"id": "ds2", "source": "billing", "format": "json",
         "content": [{"id": "C1", "amount": 500}]}
    ],
    "join_type": "inner",
    "join_keys": {"ds1": "customer_id", "ds2": "id"}
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()
print(f"Result rows: {data['result_row_count']}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class JoinDataExample {
    public static void main(String[] args) throws Exception {
        // Build JSON body — use a JSON library in production
        String body = "{\"user_id\":\"user123\","
            + "\"datasets\":[{\"id\":\"ds1\",\"source\":\"crm\",\"format\":\"json\","
            + "\"content\":[{\"customer_id\":\"C1\",\"name\":\"Alice\"}]},"
            + "{\"id\":\"ds2\",\"source\":\"billing\",\"format\":\"json\","
            + "\"content\":[{\"id\":\"C1\",\"amount\":500}]}],"
            + "\"join_type\":\"inner\","
            + "\"join_keys\":{\"ds1\":\"customer_id\",\"ds2\":\"id\"}}";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/data/join"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/privacy/redact"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "text": "My name is John Doe and my email is john.doe@example.com",
    "user_id": "user123",
    "pii_types": ["NAME", "EMAIL"],
    "replacement_strategy": "label"
}

try:
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()

    data = response.json()
    print("Redacted text:", data["redacted_text"])
    print("PII found:", data["pii_count"])

    for pii in data["pii_found"]:
        print(f"  - {pii['type']}: {pii['value']} (confidence: {pii['confidence']})")

except requests.exceptions.HTTPError as err:
    print(f"HTTP Error: {err}")
except Exception as err:
    print(f"Error: {err}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class RedactPIIExample {
    public static void main(String[] args) {
        try {
            ObjectMapper mapper = new ObjectMapper();

            Map<String, Object> payload = Map.of(
                "text", "My name is John Doe and my email is john.doe@example.com",
                "user_id", "user123",
                "pii_types", List.of("NAME", "EMAIL"),
                "replacement_strategy", "label"
            );

            String requestBody = mapper.writeValueAsString(payload);

            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.fuseais.com/api/v1/privacy/redact"))
                .header("X-API-Key", "YOUR_API_KEY")
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() != 200) {
                System.out.println("Error: HTTP " + response.statusCode());
                return;
            }

            JsonNode data = mapper.readTree(response.body());
            System.out.println("Redacted text: " + data.get("redacted_text").asText());
            System.out.println("PII count: " + data.get("pii_count").asInt());

            data.get("pii_found").forEach(pii -> {
                System.out.printf("  - %s: %s (confidence: %.2f)%n",
                    pii.get("type").asText(),
                    pii.get("value").asText(),
                    pii.get("confidence").asDouble());
            });

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import requests

url = "https://api.fuseais.com/api/v1/privacy/tokenize"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "text": "Contact Sarah Smith at sarah@company.com",
    "user_id": "user123",
    "reversible": True
}

response = requests.post(url, headers=headers, json=payload)
data = response.json()

print("Tokenized:", data["tokenized_text"])
print("Token map:", data["token_map"])

# Later, you can reverse the tokenization
def detokenize(text, token_map):
    for token, value in token_map.items():
        text = text.replace(token, value)
    return text

original = detokenize(data["tokenized_text"], data["token_map"])
print("Restored:", original)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Map;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class TokenizePIIExample {
    public static void main(String[] args) {
        try {
            ObjectMapper mapper = new ObjectMapper();

            Map<String, Object> payload = Map.of(
                "text", "Contact Sarah Smith at sarah@company.com",
                "user_id", "user123",
                "reversible", true
            );

            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.fuseais.com/api/v1/privacy/tokenize"))
                .header("X-API-Key", "YOUR_API_KEY")
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(payload)))
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            JsonNode data = mapper.readTree(response.body());
            System.out.println("Tokenized: " + data.get("tokenized_text").asText());
            System.out.println("Token map: " + data.get("token_map"));

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import requests

url = "https://api.fuseais.com/api/v1/privacy/detect"
headers = {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "text": "My SSN is 123-45-6789 and my email is john@example.com",
    "user_id": "user123",
    "min_confidence": 0.8
}

response = requests.post(url, headers=headers, json=payload)
data = response.json()

print(f"Found {data['pii_count']} PII instances")
print(f"Sensitivity score: {data['sensitive_content_score']}")
print(f"PII types: {', '.join(data['pii_types_found'])}")

# Check if content is safe to process
if data['sensitive_content_score'] > 0.7:
    print("WARNING: High sensitivity - redact before processing!")
else:
    print("Content sensitivity is acceptable")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Map;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class DetectPIIExample {
    public static void main(String[] args) {
        try {
            ObjectMapper mapper = new ObjectMapper();

            Map<String, Object> payload = Map.of(
                "text", "My SSN is 123-45-6789 and my email is john@example.com",
                "user_id", "user123",
                "min_confidence", 0.8
            );

            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.fuseais.com/api/v1/privacy/detect"))
                .header("X-API-Key", "YOUR_API_KEY")
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(payload)))
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            JsonNode data = mapper.readTree(response.body());
            System.out.println("PII count: " + data.get("pii_count").asInt());
            System.out.println("Sensitivity: " + data.get("sensitive_content_score").asDouble());

            // Check sensitivity threshold
            if (data.get("sensitive_content_score").asDouble() > 0.7) {
                System.out.println("WARNING: High sensitivity content!");
            }

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import requests

url = "https://api.fuseais.com/api/v1/privacy/files/redact"
headers = {"X-API-Key": "YOUR_API_KEY"}

with open("document.txt", "rb") as f:
    files = {"file": ("document.txt", f, "text/plain")}
    data = {
        "user_id": "user123",
        "pii_types": "NAME,EMAIL,PHONE_NUMBER",
        "replacement_strategy": "label"
    }
    response = requests.post(url, headers=headers, files=files, data=data)

result = response.json()
print("Redacted text:", result["redacted_text"])
print("PII found:", result["pii_count"])

import java.io.File;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;

public class FileRedactExample {
    public static void main(String[] args) throws Exception {
        String boundary = "----WebKitFormBoundary" + System.currentTimeMillis();
        File file = new File("document.txt");

        String body = "--" + boundary + "\r\n" +
            "Content-Disposition: form-data; name=\"file\"; filename=\"document.txt\"\r\n" +
            "Content-Type: text/plain\r\n\r\n" +
            Files.readString(file.toPath()) + "\r\n" +
            "--" + boundary + "\r\n" +
            "Content-Disposition: form-data; name=\"user_id\"\r\n\r\nuser123\r\n" +
            "--" + boundary + "\r\n" +
            "Content-Disposition: form-data; name=\"replacement_strategy\"\r\n\r\nlabel\r\n" +
            "--" + boundary + "--";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/privacy/files/redact"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/privacy/batch/redact"
headers = {"X-API-Key": "YOUR_API_KEY"}

# Prepare multiple files
files = [
    ("files", ("doc1.txt", open("doc1.txt", "rb"), "text/plain")),
    ("files", ("doc2.txt", open("doc2.txt", "rb"), "text/plain")),
    ("files", ("doc3.txt", open("doc3.txt", "rb"), "text/plain")),
]
data = {
    "user_id": "user123",
    "replacement_strategy": "label"
}

response = requests.post(url, headers=headers, files=files, data=data)
result = response.json()

print(f"Processed {result['file_count']} files")
print(f"Total PII found: {result['total_pii_count']}")

for file_result in result["results"]:
    print(f"\n{file_result['filename']}: {file_result['pii_count']} PII instances")

import java.io.File;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;

public class BatchRedactExample {
    public static void main(String[] args) throws Exception {
        String boundary = "----Boundary" + System.currentTimeMillis();
        StringBuilder body = new StringBuilder();

        // Add multiple files
        String[] filenames = {"doc1.txt", "doc2.txt", "doc3.txt"};
        for (String filename : filenames) {
            File file = new File(filename);
            body.append("--").append(boundary).append("\r\n")
                .append("Content-Disposition: form-data; name=\"files\"; filename=\"")
                .append(filename).append("\"\r\n")
                .append("Content-Type: text/plain\r\n\r\n")
                .append(Files.readString(file.toPath())).append("\r\n");
        }

        // Add user_id
        body.append("--").append(boundary).append("\r\n")
            .append("Content-Disposition: form-data; name=\"user_id\"\r\n\r\n")
            .append("user123\r\n")
            .append("--").append(boundary).append("--");

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/privacy/batch/redact"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

url = "https://api.fuseais.com/api/v1/llm/token-usage"
headers = {"X-API-Key": "YOUR_API_KEY"}

response = requests.get(url, headers=headers)
data = response.json()
print(f"Used: {data['tokens_used']}, Remaining: {data['tokens_remaining']}")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class GetTokenUsageExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.fuseais.com/api/v1/llm/token-usage"))
            .header("X-API-Key", "YOUR_API_KEY")
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import requests

response = requests.get(
    "https://api.fuseais.com/v1/models",
    headers={"X-API-Key": "YOUR_API_KEY"}
)
for model in response.json()["data"]:
    print(model["id"], "-", model["display_name"])

curl -X POST "https://api.fuseais.com/v1/messages" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.fuseais.com",
    api_key="YOUR_API_KEY",
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)
print(message.content[0].text)