Guide: Setting up a local backup for all your Humata queries and results.

The transient nature of cloud-based AI analysis platforms like Humata presents a significant data sovereignty and continuity risk for power users. While its query capabilities on uploaded documents are powerful, the platform's primary interface locks your intellectual labor—the precise questions, the extracted insights, the synthesized answers—within its ecosystem. Relying solely on the in-app history is inadequate for archival or portability. This guide details a methodical, local backup strategy that captures both your query metadata and the resultant content, ensuring you maintain an independent, queryable record.

The core mechanism leverages Humata's web interface and browser developer tools to intercept the underlying API calls. By observing network traffic during typical use, we can identify the endpoints responsible for fetching your document list and your Q&A history. The backup process is then automated via a script that simulates these authenticated requests.

**Prerequisites:**
* A Humata account with existing documents and queries.
* Node.js or Python environment for scripting.
* Your browser's network inspector (F12 -> Network tab).
* A Humata API token (extracted from an authenticated request).

**Step 1: Acquire Authentication Token**
1. Log into Humata in your browser.
2. Open Developer Tools (F12), navigate to the Network tab.
3. Refresh the main dashboard page.
4. Look for a request to an endpoint like `api/files` or `api/documents`. Inspect its Request Headers.
5. Find the `Authorization` header. It will typically contain a Bearer token (e.g., `Authorization: Bearer eyJhbG...`). Copy this token value.

**Step 2: Script the Backup**
The following Python script uses the `requests` library to sequentially fetch all documents and their associated Q&A. It structures the output into a timestamped directory.

```python
import requests
import json
import os
from datetime import datetime

HU_MATA_TOKEN = "YOUR_BEARER_TOKEN_HERE"
API_BASE = "https://api.humata.ai/api" # Confirm base URL from network tab
HEADERS = {"Authorization": f"Bearer {HU_MATA_TOKEN}"}

def fetch_all_docs():
"""Retrieves list of all uploaded documents."""
response = requests.get(f"{API_BASE}/files", headers=HEADERS)
response.raise_for_status()
return response.json().get('files', [])

def fetch_qa_for_doc(doc_id):
"""Retrieves all Q&A sessions for a specific document."""
params = {'fileId': doc_id, 'limit': 100} # Adjust limit as needed
response = requests.get(f"{API_BASE}/chat/history", headers=HEADERS, params=params)
response.raise_for_status()
return response.json().get('history', [])

def main():
backup_dir = f"humata_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
os.makedirs(backup_dir)

documents = fetch_all_docs()
master_index = []

for doc in documents:
doc_id = doc['id']
doc_filename = doc.get('originalFileName', doc_id)
print(f"Processing: {doc_filename}")

qa_history = fetch_qa_for_doc(doc_id)
doc_data = {
"metadata": doc,
"qa_history": qa_history
}

# Save per-document JSON
safe_filename = "".join(c for c in doc_filename if c.isalnum() or c in (' ', '.', '_')).rstrip()
file_path = os.path.join(backup_dir, f"{safe_filename}.json")
with open(file_path, 'w', encoding='utf-8') as f:
json.dump(doc_data, f, indent=2, ensure_ascii=False)

master_index.append({
"doc_id": doc_id,
"filename": doc_filename,
"backup_file": f"{safe_filename}.json",
"qa_count": len(qa_history)
})

# Save master index
with open(os.path.join(backup_dir, "_index.json"), 'w') as f:
json.dump(master_index, f, indent=2)

print(f"nBackup complete. {len(documents)} documents saved to '{backup_dir}'.")

if __name__ == "__main__":
main()
```

**Critical Considerations & Limitations:**
* **Token Expiry:** Bearer tokens are ephemeral. This script is designed for periodic manual execution. For full automation, you would need to implement a full OAuth flow or use a long-lived API key if Humata provides one.
* **Rate Limiting:** The script includes no rate-limiting. A large history may trigger API limits. Implement delays (`time.sleep`) between calls if necessary.
* **Data Fidelity:** This captures the textual Q&A as stored by the API. It does not capture the original document file itself, as that resides in your separate upload. You should maintain your source file archive separately.
* **API Instability:** This reverse-engineered approach is dependent on Humata's internal API structure, which is subject to change without notice. The backup may require maintenance.

This method provides a structured, machine-readable backup of your analytical work, enabling future analysis of your own query patterns or migration to another system. The `_index.json` file serves as a queryable catalog of your backed-up knowledge base.

—KH