Uploading Documents

async function uploadLargeDocument(file, folderId, apiKey) {
  try {
    // Step 1: Get presigned URL
    const presignedResponse = await fetch(
      `https://api.anam.ai/v1/knowledge/groups/${folderId}/documents/presigned-upload`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          filename: file.name,
          contentType: file.type,
          fileSize: file.size
        })
      }
    );

    if (!presignedResponse.ok) {
      throw new Error('Failed to get presigned URL');
    }

    const { uploadUrl, documentId } = await presignedResponse.json();
    console.log('Got presigned URL for document:', documentId);

    // Step 2: Upload to storage
    const uploadResponse = await fetch(uploadUrl, {
      method: 'PUT',
      headers: {
        'Content-Type': file.type
      },
      body: file
    });

    if (!uploadResponse.ok) {
      throw new Error('Failed to upload file to storage');
    }

    console.log('File uploaded to storage');

    // Step 3: Confirm upload
    const confirmResponse = await fetch(
      `https://api.anam.ai/v1/knowledge/documents/${documentId}/confirm-upload`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          fileSize: file.size
        })
      }
    );

    if (!confirmResponse.ok) {
      throw new Error('Failed to confirm upload');
    }

    const document = await confirmResponse.json();
    console.log('Upload complete! Document ID:', document.id);
    console.log('Status:', document.status);

    return document;

  } catch (error) {
    console.error('Upload error:', error);
    throw error;
  }
}

// Usage with file size check
async function uploadDocument(file, folderId, apiKey) {
console.log('Using presigned URL upload');
return await uploadLargeDocument(file, folderId, apiKey);
}

import requests
import os

def upload_document(file_path, folder_id, api_key):
    """Upload a document using presigned URL"""

    filename = os.path.basename(file_path)
    file_size = os.path.getsize(file_path)
    content_type = 'application/pdf'  # Adjust based on file type

    try:
        # Step 1: Get presigned URL
        presigned_response = requests.post(
            f'https://api.anam.ai/v1/knowledge/groups/{folder_id}/documents/presigned-upload',
            headers={
                'Authorization': f'Bearer {api_key}',
                'Content-Type': 'application/json'
            },
            json={
                'filename': filename,
                'contentType': content_type,
                'fileSize': file_size
            }
        )
        presigned_response.raise_for_status()

        data = presigned_response.json()
        upload_url = data['uploadUrl']
        document_id = data['documentId']

        print(f'Got presigned URL for document: {document_id}')

        # Step 2: Upload to storage
        with open(file_path, 'rb') as f:
            upload_response = requests.put(
                upload_url,
                headers={'Content-Type': content_type},
                data=f
            )
        upload_response.raise_for_status()

        print('File uploaded to storage')

        # Step 3: Confirm upload
        confirm_response = requests.post(
            f'https://api.anam.ai/v1/knowledge/documents/{document_id}/confirm-upload',
            headers={
                'Authorization': f'Bearer {api_key}',
                'Content-Type': 'application/json'
            },
            json={'fileSize': file_size}
        )
        confirm_response.raise_for_status()

        document = confirm_response.json()
        print(f'Upload complete! Document ID: {document["id"]}')
        print(f'Status: {document["status"]}')

        return document

    except requests.exceptions.RequestException as e:
        print(f'Upload error: {e}')
        raise

# Usage with file size check
def upload_document(file_path, folder_id, api_key):
    """Upload document using the presigned URL method"""

    print('Using presigned URL upload')
    return upload_large_document(file_path, folder_id, api_key)

curl -X GET 'https://api.anam.ai/v1/knowledge/documents/DOCUMENT_ID' \
  -H 'Authorization: Bearer YOUR_API_KEY'

async function checkDocumentStatus(documentId, apiKey) {
  const response = await fetch(
    `https://api.anam.ai/v1/knowledge/documents/${documentId}`,
    {
      headers: {
        Authorization: `Bearer ${apiKey}`,
      },
    }
  );

  const document = await response.json();
  return document.status;
}

// Poll until READY
async function waitForProcessing(documentId, apiKey) {
  const maxAttempts = 60; // 60 attempts = 5 minutes max
  let attempts = 0;

  while (attempts < maxAttempts) {
    const status = await checkDocumentStatus(documentId, apiKey);
    console.log(`Status: ${status}`);

    if (status === "READY") {
      console.log("Document is ready for search!");
      return true;
    }

    if (status === "FAILED") {
      throw new Error("Document processing failed");
    }

    // Wait 5 seconds before next check
    await new Promise((resolve) => setTimeout(resolve, 5000));
    attempts++;
  }

  throw new Error("Processing timeout");
}

import time

def check_document_status(document_id, api_key):
    """Check the processing status of a document"""

    response = requests.get(
        f'https://api.anam.ai/v1/knowledge/documents/{document_id}',
        headers={'Authorization': f'Bearer {api_key}'}
    )
    response.raise_for_status()

    document = response.json()
    return document['status']

def wait_for_processing(document_id, api_key, max_attempts=60):
    """Poll until document is ready or fails"""

    attempts = 0

    while attempts < max_attempts:
        status = check_document_status(document_id, api_key)
        print(f'Status: {status}')

        if status == 'READY':
            print('Document is ready for search!')
            return True

        if status == 'FAILED':
            raise Exception('Document processing failed')

        # Wait 5 seconds before next check
        time.sleep(5)
        attempts += 1

    raise Exception('Processing timeout')