> For the complete documentation index, see [llms.txt](https://docs.flashback.tech/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.flashback.tech/guides/setup-the-cloud-and-ai-gateway/test-a-repository/program-with-flashgate.md).

# Store An Object

{% hint style="danger" %}
The guide is experimental and may contain errors as our technology continues to evolve. If you encounter any problems, please do not hesitate to contact us in [Discord](https://discord.com/invite/yy8kyM5qFB) and give us your feedback.
{% endhint %}

This guide demonstrates how to interact with the Flashgate Platform to upload and download files in your application backend:

* [AWS S3](#aws-s3-via-boto3)
* [GCS](#google-cloud-storage-via-google-cloud-storage)
* [Azure Blob](#azure-blob-storage-via-azure-storage-blob)

## Prerequisites

{% tabs %}
{% tab title="Python" %}

* **Python 3.9+**
* A Flashgate Repository with a valid API key (READ or WRITE) – see [Create a Repository](https://chatgpt.com/g/g-p-6835f9a52acc8191af6b6fcc83a2c587-flashgate-docs/c/68386637-d934-8002-9201-ab16f5c347ea?model=o4-mini-high#create-a-repository).
* Network access to your Bridge endpoints.

**Install Required Packages**

```bash
pip install boto3 google-cloud-storage azure-storage-blob
```

{% endtab %}

{% tab title="Javascript" %}

* **Node.js v14+**
* A Flashgate Repository with a valid API key (READ or WRITE) – see [Create a Repository](https://chatgpt.com/g/g-p-6835f9a52acc8191af6b6fcc83a2c587-flashgate-docs/c/68386637-d934-8002-9201-ab16f5c347ea?model=o4-mini-high#create-a-repository).
* Network access to your Bridge endpoints

**Install Required Packages**

```bash
npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner \
            @google-cloud/storage \
            @azure/storage-blob
```

{% endtab %}

{% tab title="Go" %}

* **Go 1.18 or later**
* A Flashgate Repository with a valid API key (READ or WRITE) — see [Create a Repository](https://chatgpt.com/g/g-p-6835f9a52acc8191af6b6fcc83a2c587-flashgate-docs/c/68386637-d934-8002-9201-ab16f5c347ea?model=o4-mini-high#create-a-repository).
* Network access to your Flashgate Bridge endpoints

Install required packages:

```bash
go get github.com/aws/aws-sdk-go-v2@latest
go get github.com/aws/aws-sdk-go-v2/config
go get cloud.google.com/go/storage
go get github.com/Azure/azure-sdk-for-go/sdk/storage/azblob
```

{% endtab %}
{% endtabs %}

***

## AWS S3

{% stepper %}
{% step %}

### Configuration

Set up the S3 client with your Flashgate endpoint and credentials:

{% tabs %}
{% tab title="Python" %}

```python
# flashgate_aws_config.py
import boto3
from botocore.client import Config

# Replace with your Flashgate credentials and endpoint
ENDPOINT = "https://s3-us-east-1-aws.flashback.tech"
# Consider READ/WRITE API Information of the Repository
API_KEY_ID = "YOUR_API_KEY_ID"
API_SECRET = "YOUR_API_SECRET"

session = boto3.session.Session(
    aws_access_key_id=API_KEY_ID,
    aws_secret_access_key=API_SECRET
)

s3_client = session.client(
    service_name="s3",
    endpoint_url=ENDPOINT,
    config=Config(signature_version="s3v4")
)
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// flashgateAwsConfig.js
import { S3Client } from "@aws-sdk/client-s3";

// Replace with your Flashgate credentials and endpoint
const ENDPOINT   = "https://s3-us-east-1-aws.flashback.tech";
const API_KEY_ID = "YOUR_API_KEY_ID";
const API_SECRET = "YOUR_API_SECRET";

export const s3Client = new S3Client({
  endpoint: ENDPOINT,
  region:   "us-east-1",
  credentials: {
    accessKeyId:     API_KEY_ID,
    secretAccessKey: API_SECRET
  },
  forcePathStyle: true
});
```

{% endtab %}

{% tab title="Go" %}

```go
// flashgate_aws_config.go
package flashgate

import (
  "context"
  "github.com/aws/aws-sdk-go-v2/aws"
  "github.com/aws/aws-sdk-go-v2/config"
  "github.com/aws/aws-sdk-go-v2/credentials"
  "github.com/aws/aws-sdk-go-v2/service/s3"
  s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
)

func NewS3Client() (*s3.Client, error) {
  // Replace with your Flashgate endpoint and credentials
  endpoint   := "https://s3-us-east-1-aws.flashback.tech"
  apiKey     := "YOUR_API_KEY_ID"
  apiSecret  := "YOUR_API_SECRET"

  // Load default config and override credentials and endpoint
  cfg, err := config.LoadDefaultConfig(context.TODO(),
    config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(apiKey, apiSecret, "")),
    config.WithEndpointResolverWithOptions(aws.EndpointResolverWithOptionsFunc(
      func(service, region string, opts ...interface{}) (aws.Endpoint, error) {
        if service == s3.ServiceID {
          return aws.Endpoint{
            URL:           endpoint,
            SigningRegion: "us-east-1",
          }, nil
        }
        return aws.Endpoint{}, &aws.EndpointNotFoundError{}
      })),
  )
  if err != nil {
    return nil, err
  }

  return s3.NewFromConfig(cfg, func(o *s3.Options) {
    o.UsePathStyle = true
  }), nil
}
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Upload a File

Upload a local file to your specified bucket:

{% tabs %}
{% tab title="Python" %}

<pre class="language-python"><code class="lang-python"># aws_upload.py
from flashgate_aws_config import s3_client

<strong>#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
</strong>BUCKET_NAME = "your-bucket-name"
FILE_PATH = "path/to/local/file.txt"
OBJECT_NAME = FILE_PATH.split("/")[-1]

s3_client.upload_file(
    Filename=FILE_PATH,
    Bucket=BUCKET_NAME,
    Key=OBJECT_NAME
)
print(f"Uploaded {OBJECT_NAME} to {BUCKET_NAME}")
</code></pre>

{% endtab %}

{% tab title="Javascript" %}

```javascript
// awsUpload.js
import { PutObjectCommand } from "@aws-sdk/client-s3";
import fs                  from "fs";
import { s3Client }        from "./flashgateAwsConfig.js";

const BUCKET_NAME = "your-bucket-name";
const FILE_PATH   = "path/to/local/file.txt";
const OBJECT_NAME = FILE_PATH.split("/").pop();
const BODY        = fs.readFileSync(FILE_PATH);

(async () => {
  await s3Client.send(new PutObjectCommand({
    Bucket: BUCKET_NAME,
    Key:    OBJECT_NAME,
    Body
  }));
  console.log(`Uploaded ${OBJECT_NAME} to ${BUCKET_NAME}`);
})();
```

{% endtab %}

{% tab title="Go" %}

```go
// aws_upload.go
package main

import (
  "context"
  "fmt"
  "flashgate"
  "os"
)

func main() {
  client, err := flashgate.NewS3Client()
  if err != nil {
    panic(err)
  }

  bucket := "your-bucket-name"
  key    := "file.txt"
  file, err := os.Open("path/to/local/file.txt")
  if err != nil {
    panic(err)
  }
  defer file.Close()

  _, err = client.PutObject(context.TODO(), &s3.PutObjectInput{
    Bucket: aws.String(bucket),
    Key:    aws.String(key),
    Body:   file,
  })
  if err != nil {
    panic(err)
  }

  fmt.Printf("Uploaded %s to %s\n", key, bucket)
}
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Download a File

Download an object from your repository to a local path:

{% tabs %}
{% tab title="Python" %}

```python
# aws_download.py
from flashgate_aws_config import s3_client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-bucket-name"
OBJECT_NAME = "file.txt"
DEST_PATH = "downloads/file.txt"

s3_client.download_file(
    Bucket=BUCKET_NAME,
    Key=OBJECT_NAME,
    Filename=DEST_PATH
)
print(f"Downloaded {OBJECT_NAME} to {DEST_PATH}")
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// awsDownload.js
import { GetObjectCommand } from "@aws-sdk/client-s3";
import fs                  from "fs";
import { s3Client }        from "./flashgateAwsConfig.js";

const BUCKET_NAME = "your-bucket-name";
const OBJECT_NAME = "file.txt";
const DEST_PATH   = "downloads/file.txt";

(async () => {
  const { Body } = await s3Client.send(new GetObjectCommand({
    Bucket: BUCKET_NAME,
    Key:    OBJECT_NAME
  }));
  const chunks = [];
  for await (let chunk of Body) chunks.push(chunk);
  fs.writeFileSync(DEST_PATH, Buffer.concat(chunks));
  console.log(`Downloaded ${OBJECT_NAME} to ${DEST_PATH}`);
})();
```

{% endtab %}

{% tab title="Go" %}

```go
// aws_download.go
package main

import (
  "context"
  "fmt"
  "flashgate"
  "io"
  "os"
)

func main() {
  client, err := flashgate.NewS3Client()
  if err != nil {
    panic(err)
  }

  bucket   := "your-bucket-name"
  key      := "file.txt"
  destPath := "downloads/file.txt"

  resp, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
    Bucket: aws.String(bucket),
    Key:    aws.String(key),
  })
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  outFile, err := os.Create(destPath)
  if err != nil {
    panic(err)
  }
  defer outFile.Close()

  if _, err = io.Copy(outFile, resp.Body); err != nil {
    panic(err)
  }

  fmt.Printf("Downloaded %s to %s\n", key, destPath)
}
```

5.

{% endtab %}
{% endtabs %}
{% endstep %}
{% endstepper %}

***

## Google Cloud Storage

{% stepper %}
{% step %}

### Configuration

Initialize a GCS client pointing to your Flashgate Bridge endpoint:

{% tabs %}
{% tab title="Python" %}

```python
# flashgate_gcs_config.py
from google.cloud import storage
from google.oauth2 import service_account

# Replace with your Flashgate credentials and endpoint
ENDPOINT = "https://s3-us-east-1.aws.flashback.tech"
# Consider READ/WRITE API Information of the Repository
CLIENT_EMAIL = "YOUR_CLIENT_EMAIL"
PRIVATE_KEY = "YOUR_PRIVATE_KEY"

credentials = service_account.Credentials.from_service_account_info({
    "type": "service_account",
    "client_email": CLIENT_EMAIL,
    "private_key": PRIVATE_KEY,
})

client = storage.Client(
    credentials=credentials,
    client_options={"api_endpoint": ENDPOINT}
)
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// flashgateGcsConfig.js
import { Storage } from '@google-cloud/storage';

// Replace with your Flashgate credentials and endpoint
const ENDPOINT     = 'https://s3-us-east-1.aws.flashback.tech';
const CLIENT_EMAIL = 'YOUR_CLIENT_EMAIL';
const PRIVATE_KEY  = 'YOUR_PRIVATE_KEY';

// Initialize client
const storage = new Storage({
  credentials: {
    client_email: CLIENT_EMAIL,
    private_key: PRIVATE_KEY.replace(/\\n/g, '\n'),
  },
  apiEndpoint: ENDPOINT.replace(/^https?:\/\//, ''),
});

export default storage;
)
```

{% endtab %}

{% tab title="Go" %}

```go
// flashgate_gcs_config.go
package flashgate

import (
  "context"
  "fmt"
  "cloud.google.com/go/storage"
  "google.golang.org/api/option"
)

const (
  // Replace with your Flashgate Bridge endpoint and service account info
  ENDPOINT     = "https://s3-us-east-1.aws.flashback.tech"
  CLIENT_EMAIL = "YOUR_CLIENT_EMAIL"
  PRIVATE_KEY  = `-----BEGIN PRIVATE KEY-----
YOUR_PRIVATE_KEY_CONTENT
-----END PRIVATE KEY-----`
  // The GCP project ID associated with your Flashgate repository
  PROJECT_ID   = "your-gcp-project-id"
)

func NewGCSClient() (*storage.Client, string, error) {
  ctx := context.Background()
  credsJSON := []byte(fmt.Sprintf(
    `{"type":"service_account","client_email":"%s","private_key":"%s"}`,
    CLIENT_EMAIL, PRIVATE_KEY,
  ))
  client, err := storage.NewClient(ctx,
    option.WithCredentialsJSON(credsJSON),
    option.WithEndpoint(ENDPOINT),
  )
  if err != nil {
    return nil, "", err
  }
  return client, PROJECT_ID, nil
}
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Upload a File as a Blob

Upload a blob to the specified GCS bucket:

{% tabs %}
{% tab title="Python" %}

```python
# gcs_upload.py
from flashgate_gcs_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-flashgate-bucket-name"
FILE_PATH = "path/to/local/file.txt"
OBJECT_NAME = FILE_PATH.split("/")[-1]

bucket = client.bucket(BUCKET_NAME)
blob = bucket.blob(OBJECT_NAME)
blob.upload_from_filename(FILE_PATH)
print(f"Uploaded {OBJECT_NAME} to {BUCKET_NAME}")
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// gcsUpload.js
import storage from './flashgateGcsConfig.js';

const BUCKET_NAME = 'your-flashgate-bucket-name';
const FILE_PATH   = 'path/to/local/file.txt';
const OBJECT_NAME = FILE_PATH.split('/').pop();

(async () => {
  const bucket = storage.bucket(BUCKET_NAME);
  await bucket.upload(FILE_PATH, { destination: OBJECT_NAME });
  console.log(`Uploaded ${OBJECT_NAME} to ${BUCKET_NAME}`);
})();
```

{% endtab %}

{% tab title="Go" %}

```go
// gcs_upload.go
package main

import (
  "context"
  "fmt"
  "flashgate"
  "io"
  "os"
)

func main() {
  client, _, err := flashgate.NewGCSClient()
  if err != nil {
    panic(err)
  }
  ctx := context.Background()
  bucketName := "your-flashgate-bucket-name"
  filePath   := "path/to/local/file.txt"
  objectName := "file.txt"

  bucket := client.Bucket(bucketName)
  writer := bucket.Object(objectName).NewWriter(ctx)
  f, err := os.Open(filePath)
  if err != nil {
    panic(err)
  }
  defer f.Close()
  if _, err = io.Copy(writer, f); err != nil {
    panic(err)
  }
  if err := writer.Close(); err != nil {
    panic(err)
  }
  fmt.Printf("Uploaded %s to %s\n", objectName, bucketName)
}
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Download a File as a Blob

Download a blob from your repository:

{% tabs %}
{% tab title="Python" %}

```python
# gcs_download.py
from flashgate_gcs_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
BUCKET_NAME = "your-bucket-name"
OBJECT_NAME = "file.txt"
DEST_PATH = "downloads/file.txt"

bucket = client.bucket(BUCKET_NAME)
blob = bucket.blob(OBJECT_NAME)
blob.download_to_filename(DEST_PATH)
print(f"Downloaded {OBJECT_NAME} to {DEST_PATH}")
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// gcsDownload.js
import storage from './flashgateGcsConfig.js';

const BUCKET_NAME = 'your-bucket-name';
const OBJECT_NAME = 'file.txt';
const DEST_PATH   = 'downloads/file.txt';

(async () => {
  const bucket = storage.bucket(BUCKET_NAME);
  const blob = bucket.file(OBJECT_NAME);
  await blob.download({ destination: DEST_PATH });
  console.log(`Downloaded ${OBJECT_NAME} to ${DEST_PATH}`);
})();
```

{% endtab %}

{% tab title="Go" %}

```go
// gcs_download.go
package main

import (
  "context"
  "fmt"
  "flashgate"
  "io"
  "os"
)

func main() {
  client, _, err := flashgate.NewGCSClient()
  if err != nil {
    panic(err)
  }
  ctx := context.Background()
  bucketName := "your-bucket-name"
  objectName := "file.txt"
  destPath   := "downloads/file.txt"

  reader, err := client.Bucket(bucketName).Object(objectName).NewReader(ctx)
  if err != nil {
    panic(err)
  }
  defer reader.Close()
  f, err := os.Create(destPath)
  if err != nil {
    panic(err)
  }
  defer f.Close()
  if _, err = io.Copy(f, reader); err != nil {
    panic(err)
  }
  fmt.Printf("Downloaded %s to %s\n", objectName, destPath)
}
```

{% endtab %}
{% endtabs %}
{% endstep %}
{% endstepper %}

***

## Azure Blob Storage

{% stepper %}
{% step %}

### Configuration

Create an Azure BlobServiceClient using your Flashgate endpoint:

{% tabs %}
{% tab title="Python" %}

```python
# flashgate_azure_config.py
from azure.storage.blob import BlobServiceClient

# Replace with your Flashgate endpoint and credentials
ENDPOINT = "https://s3-us-east-1.aws.flashback.tech"
# Consider READ/WRITE API Information of the Repository
CREDENTIAL = "YOUR_CREDENTIAL"

client = BlobServiceClient(
    account_url=ENDPOINT,
    credential=CREDENTIAL
)
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// flashgateAzureConfig.js
import { BlobServiceClient, StorageSharedKeyCredential } from "@azure/storage-blob";

// Replace with your Flashgate endpoint and credential
const ENDPOINT   = "https://s3-us-east-1.aws.flashback.tech";
const ACCOUNT    = "YOUR_ACCOUNT_NAME";
const ACCOUNT_KEY= "YOUR_ACCOUNT_KEY";

const credential = new StorageSharedKeyCredential(ACCOUNT, ACCOUNT_KEY);
export const blobServiceClient = new BlobServiceClient(ENDPOINT, credential);
```

{% endtab %}

{% tab title="Go" %}

```go
// flashgate_azure_config.go
package flashgate

import (
  "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

// Replace with your Flashgate endpoint and credentials
const (
  ENDPOINT     = "https://s3-us-east-1.aws.flashback.tech"
  ACCOUNT_NAME = "YOUR_ACCOUNT_NAME"
  ACCOUNT_KEY  = "YOUR_ACCOUNT_KEY"
)

// NewBlobServiceClient returns an authenticated ServiceClient
func NewBlobServiceClient() (*azblob.ServiceClient, error) {
  cred, err := azblob.NewSharedKeyCredential(ACCOUNT_NAME, ACCOUNT_KEY)
  if err != nil {
    return nil, err
  }
  return azblob.NewServiceClientWithSharedKey(ENDPOINT, cred, nil)
}
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Upload a File as a Blob

Upload a local file as a blob to your bucket:

{% tabs %}
{% tab title="Python" %}

```python
# azure_upload.py
from flashgate_azure_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
CONTAINER_NAME = "your-bucket_name"
FILE_PATH = "path/to/local/file.txt"
BLOB_NAME = FILE_PATH.split("/")[-1]

blob_client = client.get_blob_client(container=CONTAINER_NAME, blob=BLOB_NAME)
with open(FILE_PATH, "rb") as data:
    blob_client.upload_blob(data)
print(f"Uploaded {BLOB_NAME} to {CONTAINER_NAME}")
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// azureUpload.js
import { blobServiceClient } from "./flashgateAzureConfig.js";
import fs                     from "fs";

const CONTAINER_NAME = "your-bucket-name";
const FILE_PATH      = "path/to/local/file.txt";
const BLOB_NAME      = FILE_PATH.split("/").pop();

(async () => {
  const containerClient = blobServiceClient.getContainerClient(CONTAINER_NAME);
  const blockBlobClient = containerClient.getBlockBlobClient(BLOB_NAME);
  await blockBlobClient.uploadFile(FILE_PATH);
  console.log(`Uploaded ${BLOB_NAME} to ${CONTAINER_NAME}`);
})();
```

{% endtab %}

{% tab title="Go" %}

```go
// azure_upload.go
package main

import (
  "context"
  "fmt"
  "flashgate"
  "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

func main() {
  client, err := flashgate.NewBlobServiceClient()
  if err != nil {
    panic(err)
  }
  containerName := "your-bucket-name"
  blobName      := "file.txt"
  localPath     := "path/to/local/file.txt"

  containerClient := client.NewContainerClient(containerName)
  blobClient := containerClient.NewBlockBlobClient(blobName)

  resp, err := blobClient.UploadFile(context.Background(), localPath, nil)
  if err != nil {
    panic(err)
  }
  fmt.Printf("Uploaded %s to %s (request ID: %s)\n", blobName, containerName, *resp.RequestID)
}
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Download a File as a Blob

Download a blob from your container to a local path:

{% tabs %}
{% tab title="Python" %}

```python
# azure_download.py
from flashgate_azure_config import client

#S3 Bucket, GCS Bucket, or Azure Container listed in your Repository
CONTAINER_NAME = "your-flashgate-bucket_name"
BLOB_NAME = "file.txt"
DEST_PATH = "downloads/file.txt"

blob_client = client.get_blob_client(container=CONTAINER_NAME, blob=BLOB_NAME)
with open(DEST_PATH, "wb") as file:
    data = blob_client.download_blob()
    file.write(data.readall())
print(f"Downloaded {BLOB_NAME} to {DEST_PATH}")
```

{% endtab %}

{% tab title="Javascript" %}

```javascript
// azureDownload.js
import { blobServiceClient } from "./flashgateAzureConfig.js";
import fs                     from "fs";

const CONTAINER_NAME = "your-flashgate-bucket-name";
const BLOB_NAME      = "file.txt";
const DEST_PATH      = "downloads/file.txt";

(async () => {
  const containerClient = blobServiceClient.getContainerClient(CONTAINER_NAME);
  const blockBlobClient = containerClient.getBlockBlobClient(BLOB_NAME);
  await blockBlobClient.downloadToFile(DEST_PATH);
  console.log(`Downloaded ${BLOB_NAME} to ${DEST_PATH}`);
})();
```

{% endtab %}

{% tab title="Go" %}

```go
// azure_download.go
package main

import (
  "context"
  "fmt"
  "io"
  "os"
  "flashgate"
)

func main() {
  client, err := flashgate.NewBlobServiceClient()
  if err != nil {
    panic(err)
  }
  containerName := "your-flashgate-bucket-name"
  blobName      := "file.txt"
  destPath      := "downloads/file.txt"

  containerClient := client.NewContainerClient(containerName)
  blobClient := containerClient.NewBlockBlobClient(blobName)

  downloadResp, err := blobClient.DownloadStream(context.Background(), nil)
  if err != nil {
    panic(err)
  }
  defer downloadResp.Body.Close()

  outFile, err := os.Create(destPath)
  if err != nil {
    panic(err)
  }
  defer outFile.Close()

  if _, err = io.Copy(outFile, downloadResp.Body); err != nil {
    panic(err)
  }
  fmt.Printf("Downloaded %s to %s\n", blobName, destPath)
}
```

{% endtab %}
{% endtabs %}
{% endstep %}
{% endstepper %}

***

## Next Steps

* Explore additional [storage API operations](https://github.com/flashbacknetwork/flashback-usermanual/blob/main/support-reference/storage-api-operations/README.md): delete, copy, multipart uploads, etc.
* Integrate and modify these snippets into your applications.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.flashback.tech/guides/setup-the-cloud-and-ai-gateway/test-a-repository/program-with-flashgate.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.