> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ubik-agent.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Guide : Gérer les Espaces de Travail

> Apprenez à organiser vos données avec les espaces de travail en utilisant l'API UBIK.

Ce guide vous expliquera un scénario d'utilisation courant : créer un nouvel espace de travail, y ajouter un document à partir d'une URL, puis vérifier que le document est correctement associé à l'espace de travail.

<Steps>
  <Step title="Créer un Nouvel Espace de Travail">
    Tout d'abord, créons un nouvel espace de travail pour contenir nos documents. Nous effectuerons une requête `POST` vers l'endpoint `/workspaces`. Vous pouvez lui donner un nom et une description pour garder les choses organisées.

    <CodeGroup title="POST /workspaces">
      ```bash cURL theme={null}
      curl -X POST "https://app.ubik-agent.com/api/v1/workspaces" \
           -H "X-API-KEY: VOTRE_CLE_API" \
           -H "Content-Type: application/json" \
           -d '{
                "name": "Mon Premier Projet",
                "description": "Espace de travail pour mon premier projet avec l''API UBIK."
              }'
      ```

      ```python Python theme={null}
      import requests

      api_key = "VOTRE_CLE_API"
      headers = {
          "X-API-KEY": api_key,
          "Content-Type": "application/json"
      }
      payload = {
          "name": "Mon Premier Projet",
          "description": "Espace de travail pour mon premier projet avec l''API UBIK."
      }
      response = requests.post(
          "https://app.ubik-agent.com/api/v1/workspaces",
          headers=headers,
          json=payload
      )

      if response.status_code == 200:
          workspace = response.json()
          print(workspace)
          # Conservez le workspace['id'] pour les étapes suivantes
      else:
          print(f"Erreur: {response.status_code}", response.text)
      ```

      ```javascript JavaScript theme={null}
      const apiKey = "VOTRE_CLE_API";
      const url = "https://app.ubik-agent.com/api/v1/workspaces";

      const payload = {
        name: "Mon Premier Projet",
        description: "Espace de travail pour mon premier projet avec l''API UBIK."
      };

      fetch(url, {
        method: 'POST',
        headers: {
          'X-API-KEY': apiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(payload)
      })
      .then(response => {
        if (!response.ok) {
          throw new Error(`Erreur HTTP: ${response.status}`);
        }
        return response.json();
      })
      .then(workspace => {
        console.log(workspace);
        // Conservez l'ID de l'espace de travail pour les étapes suivantes
      })
      .catch(error => console.error('Erreur:', error));
      ```
    </CodeGroup>

    L'API répondra avec les détails de l'espace de travail nouvellement créé, y compris son `id` unique. Conservez cet `id` car nous en aurons besoin à l'étape suivante.
  </Step>

  <Step title="Ajouter un Document à l'Espace de Travail">
    Maintenant que nous avons un espace de travail, ajoutons-y un document. Vous pouvez ingérer du contenu depuis une URL ou en téléversant un fichier directement. En passant les `workspace_ids` dans la requête, le nouveau document sera automatiquement associé à notre nouvel espace de travail.

    <CodeGroup title="POST /documents (depuis une URL)">
      ```bash cURL theme={null}
      curl -X POST "https://app.ubik-agent.com/api/v1/documents" \
           -H "X-API-KEY: VOTRE_CLE_API" \
           -F "urls=https://www.ubik-agent.com/" \
           -F "workspace_ids=VOTRE_ID_ESPACE_DE_TRAVAIL"
      ```

      ```python Python theme={null}
      import requests

      api_key = "VOTRE_CLE_API"
      workspace_id = "VOTRE_ID_ESPACE_DE_TRAVAIL" # Remplacez par l'ID de l'étape 1

      headers = {"X-API-KEY": api_key}
      data = {
          "urls": "https://www.ubik-agent.com/",
          "workspace_ids": workspace_id
      }

      response = requests.post(
          "https://app.ubik-agent.com/api/v1/documents",
          headers=headers,
          data=data
      )

      if response.status_code == 200:
          documents = response.json()
          print("Document en cours de traitement :", documents[0]['id'])
      else:
          print(f"Erreur: {response.status_code}", response.text)
      ```

      ```javascript JavaScript theme={null}
      const apiKey = "VOTRE_CLE_API";
      const workspaceId = "VOTRE_ID_ESPACE_DE_TRAVAIL"; // Remplacez par l'ID de l'étape 1
      const url = "https://app.ubik-agent.com/api/v1/documents";

      const formData = new FormData();
      formData.append('urls', 'https://www.ubik-agent.com/');
      formData.append('workspace_ids', workspaceId);

      fetch(url, {
        method: 'POST',
        headers: {
          'X-API-KEY': apiKey
        },
        body: formData
      })
      .then(response => {
        if (!response.ok) {
          throw new Error(`Erreur HTTP: ${response.status}`);
        }
        return response.json();
      })
      .then(documents => {
        console.log('Document en cours de traitement:', documents[0].id);
      })
      .catch(error => console.error('Erreur:', error));
      ```
    </CodeGroup>

    <CodeGroup title="POST /documents (depuis un fichier)">
      ```bash cURL theme={null}
      curl -X POST "https://app.ubik-agent.com/api/v1/documents" \
           -H "X-API-KEY: VOTRE_CLE_API" \
           -F "files=@/chemin/vers/votre/fichier.pdf" \
           -F "workspace_ids=VOTRE_ID_ESPACE_DE_TRAVAIL"
      ```

      ```python Python theme={null}
      import requests

      api_key = "VOTRE_CLE_API"
      workspace_id = "VOTRE_ID_ESPACE_DE_TRAVAIL" # Remplacez par l'ID de l'étape 1
      file_path = "/chemin/vers/votre/fichier.pdf"

      headers = {"X-API-KEY": api_key}
      data = {"workspace_ids": workspace_id}

      with open(file_path, "rb") as f:
        files = {"files": (file_path, f)}
        response = requests.post(
            "https://app.ubik-agent.com/api/v1/documents",
            headers=headers,
            data=data,
            files=files
        )

      if response.status_code == 200:
          documents = response.json()
          print("Document en cours de traitement :", documents[0]['id'])
      else:
          print(f"Erreur: {response.status_code}", response.text)
      ```

      ```javascript JavaScript theme={null}
      const apiKey = "VOTRE_CLE_API";
      const workspaceId = "VOTRE_ID_ESPACE_DE_TRAVAIL"; // Remplacez par l'ID de l'étape 1
      const url = "https://app.ubik-agent.com/api/v1/documents";

      // Cet exemple suppose que vous avez un objet File.
      // Dans un navigateur, vous pouvez l'obtenir depuis un élément <input type="file">.
      const myFile = new File(["Ceci est le contenu du fichier."], "exemple.txt", {
        type: "text/plain",
      });

      const formData = new FormData();
      formData.append('files', myFile);
      formData.append('workspace_ids', workspaceId);

      fetch(url, {
        method: 'POST',
        headers: {
          'X-API-KEY': apiKey
        },
        body: formData
      })
      .then(response => {
        if (!response.ok) {
          throw new Error(`Erreur HTTP: ${response.status}`);
        }
        return response.json();
      })
      .then(documents => {
        console.log('Document en cours de traitement :', documents[0].id);
      })
      .catch(error => console.error('Erreur :', error));
      ```
    </CodeGroup>

    <Note>
      Le traitement des documents est asynchrone. L'API répondra immédiatement avec les détails du document et son statut (`pending` ou `processing`). Vous pouvez interroger l'endpoint du document pour vérifier quand le statut passe à `completed`.
    </Note>
  </Step>

  <Step title="Vérifier le Contenu de l'Espace de Travail">
    Enfin, vérifions que notre document a bien été ajouté à l'espace de travail. Nous ferons une requête `GET` vers l'endpoint `/workspaces/{workspace_id}/documents`.

    <CodeGroup title="GET /workspaces/{workspace_id}/documents">
      ```bash cURL theme={null}
      curl -X GET "https://app.ubik-agent.com/api/v1/workspaces/VOTRE_ID_ESPACE_DE_TRAVAIL/documents" \
           -H "X-API-KEY: VOTRE_CLE_API"
      ```

      ```python Python theme={null}
      import requests

      api_key = "VOTRE_CLE_API"
      workspace_id = "VOTRE_ID_ESPACE_DE_TRAVAIL"

      headers = {"X-API-KEY": api_key}

      response = requests.get(
          f"https://app.ubik-agent.com/api/v1/workspaces/{workspace_id}/documents",
          headers=headers
      )

      if response.status_code == 200:
          workspace_docs = response.json()
          print(workspace_docs)
      else:
          print(f"Erreur: {response.status_code}", response.text)
      ```

      ```javascript JavaScript theme={null}
      const apiKey = "VOTRE_CLE_API";
      const workspaceId = "VOTRE_ID_ESPACE_DE_TRAVAIL";
      const url = `https://app.ubik-agent.com/api/v1/workspaces/${workspaceId}/documents`;

      fetch(url, {
        method: 'GET',
        headers: {
          'X-API-KEY': apiKey
        }
      })
      .then(response => {
        if (!response.ok) {
          throw new Error(`Erreur HTTP: ${response.status}`);
        }
        return response.json();
      })
      .then(workspaceDocs => {
        console.log(workspaceDocs);
      })
      .catch(error => console.error('Erreur:', error));
      ```
    </CodeGroup>

    La réponse confirmera que le document que nous avons ajouté à l'étape 2 est maintenant listé dans cet espace de travail.
  </Step>

  <Step title="Récupérer le Contenu du Document">
    Une fois qu'un document a été traité avec succès (`status: "completed"`), vous pouvez récupérer son contenu. L'API fournit une représentation Markdown du document, ce qui est utile pour l'envoyer à des LLMs ou pour l'afficher.

    <CodeGroup title="GET /documents/{document_id}">
      ```bash cURL theme={null}
      curl -X GET "https://app.ubik-agent.com/api/v1/documents/VOTRE_ID_DOCUMENT" \
           -H "X-API-KEY: VOTRE_CLE_API"
      ```

      ```python Python theme={null}
      import requests

      api_key = "VOTRE_CLE_API"
      document_id = "VOTRE_ID_DOCUMENT" # Remplacez par l'ID d'un document traité

      headers = {"X-API-KEY": api_key}

      response = requests.get(
          f"https://app.ubik-agent.com/api/v1/documents/{document_id}",
          headers=headers
      )

      if response.status_code == 200:
          document_details = response.json()
          print(document_details['markdown_content'])
      else:
          print(f"Erreur: {response.status_code}", response.text)
      ```

      ```javascript JavaScript theme={null}
      const apiKey = "VOTRE_CLE_API";
      const documentId = "VOTRE_ID_DOCUMENT"; // Remplacez par l'ID d'un document traité

      fetch(`https://app.ubik-agent.com/api/v1/documents/${documentId}`, {
        method: "GET",
        headers: { "X-API-KEY": apiKey },
      })
        .then(response => {
          if (!response.ok) {
            throw new Error(`Erreur HTTP: ${response.status}`);
          }
          return response.json();
        })
        .then(documentDetails => {
          console.log(documentDetails.markdown_content);
        })
        .catch(error => console.error("Erreur:", error));
      ```
    </CodeGroup>

    La réponse inclura les détails complets du document, y compris le `markdown_content`.
  </Step>
</Steps>

Félicitations ! Vous avez correctement créé un espace de travail, y avez ajouté un document, vérifié son contenu et récupéré son rendu traité. Vous êtes maintenant prêt à gérer l'organisation du contenu dans vos projets UBIK.