Add Webpage to Context

curl -X POST "https://api.synvo.ai/webpage/add" \
  -H "X-API-Key: ${API-KEY}" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "url=https://example.com/article" \
  --data-urlencode "path=/research"

import requests

api_key = "<API_KEY>"
url = "https://api.synvo.ai/webpage/add"
data = {
    "url": "https://example.com/article",
    "path": "/research"
}
headers = {"X-API-Key": api_key}

response = requests.post(url, data=data, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const apiKey = "<API_KEY>";
const params = new URLSearchParams({
  url: "https://example.com/article",
  path: "/research"
});

const response = await fetch("https://api.synvo.ai/webpage/add", {
  method: "POST",
  headers: {
    "X-API-Key": apiKey,
  },
  body: params,
});

if (!response.ok) {
  throw new Error(`Request failed: ${response.status}`);
}

console.log(await response.json());

import requests
import time

api_key = "<API_KEY>"
BASE_URL = "https://api.synvo.ai"

# List of webpages to add
webpages = [
    {"url": "https://example.com/article1", "path": "/research"},
    {"url": "https://example.com/article2", "path": "/research"},
    {"url": "https://example.com/blog-post", "path": "/blog"},
]

# Step 1: Upload all webpages
print("📤 Uploading webpages...")
file_ids = {}

for webpage in webpages:
    try:
        response = requests.post(
            f"{BASE_URL}/webpage/add",
            data=webpage,
            headers={"X-API-Key": api_key},
            timeout=30
        )
        response.raise_for_status()
        result = response.json()
        
        file_id = result.get("file_id")
        file_ids[webpage["url"]] = file_id
        print(f"✓ Uploaded: {webpage['url']} (ID: {file_id})")
        
        time.sleep(0.5)  # Rate limiting
        
    except Exception as e:
        print(f"✗ Failed to upload {webpage['url']}: {e}")

# Step 2: Wait for all files to complete processing
print("\n⏳ Waiting for all files to process...")
for url, file_id in file_ids.items():
    max_retries = 60  # Maximum 5 minutes (60 * 5 seconds)
    retries = 0
    
    while retries < max_retries:
        try:
            status_response = requests.get(
                f"{BASE_URL}/file/status/{file_id}",
                headers={"X-API-Key": api_key},
                timeout=10
            )
            status_response.raise_for_status()
            status = status_response.json()["status"]
            
            if status == "COMPLETED":
                print(f"✅ {url} - Processing complete!")
                break
            elif status == "FAILED":
                print(f"❌ {url} - Processing failed!")
                break
            
            retries += 1
            time.sleep(5)
            
        except Exception as e:
            print(f"⚠️  Error checking status for {url}: {e}")
            retries += 1
            time.sleep(5)
    
    if retries >= max_retries:
        print(f"⏱️  {url} - Timeout waiting for processing")

# Step 3: Summary
print("\n🎉 All files ready for querying!")
print("\nProcessed File IDs:")
for url, file_id in file_ids.items():
    print(f"  {file_id}: {url}")

const apiKey = "<API_KEY>";
const BASE_URL = "https://api.synvo.ai";

// List of webpages to add
const webpages = [
  { url: "https://example.com/article1", path: "/research" },
  { url: "https://example.com/article2", path: "/research" },
  { url: "https://example.com/blog-post", path: "/blog" },
];

async function batchUploadWithVerification() {
  // Step 1: Upload all webpages
  console.log("📤 Uploading webpages...");
  const fileIds = {};

  for (const webpage of webpages) {
    try {
      const params = new URLSearchParams(webpage);
      const response = await fetch(`${BASE_URL}/webpage/add`, {
        method: "POST",
        headers: { "X-API-Key": apiKey },
        body: params,
      });

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }

      const result = await response.json();
      const fileId = result.file_id;
      fileIds[webpage.url] = fileId;
      console.log(`✓ Uploaded: ${webpage.url} (ID: ${fileId})`);

      await new Promise(resolve => setTimeout(resolve, 500)); // Rate limiting
    } catch (error) {
      console.log(`✗ Failed to upload ${webpage.url}: ${error.message}`);
    }
  }

  // Step 2: Wait for all files to complete processing
  console.log("\n⏳ Waiting for all files to process...");
  
  for (const [url, fileId] of Object.entries(fileIds)) {
    const maxRetries = 60; // Maximum 5 minutes (60 * 5 seconds)
    let retries = 0;

    while (retries < maxRetries) {
      try {
        const statusResponse = await fetch(
          `${BASE_URL}/file/status/${fileId}`,
          { headers: { "X-API-Key": apiKey } }
        );

        if (!statusResponse.ok) {
          throw new Error(`HTTP ${statusResponse.status}`);
        }

        const data = await statusResponse.json();
        const status = data.status;

        if (status === "COMPLETED") {
          console.log(`✅ ${url} - Processing complete!`);
          break;
        } else if (status === "FAILED") {
          console.log(`❌ ${url} - Processing failed!`);
          break;
        }

        retries++;
        await new Promise(resolve => setTimeout(resolve, 5000));
      } catch (error) {
        console.log(`⚠️  Error checking status for ${url}: ${error.message}`);
        retries++;
        await new Promise(resolve => setTimeout(resolve, 5000));
      }
    }

    if (retries >= maxRetries) {
      console.log(`⏱️  ${url} - Timeout waiting for processing`);
    }
  }

  // Step 3: Summary
  console.log("\n🎉 All files ready for querying!");
  console.log("\nProcessed File IDs:");
  for (const [url, fileId] of Object.entries(fileIds)) {
    console.log(`  ${fileId}: ${url}`);
  }
}

// Execute batch operation
batchUploadWithVerification();