### Install Torch-XLA for PyTorch TPU Training

Source: https://www.kaggle.com/docs/tpu

Install the necessary Torch-XLA environment for PyTorch to enable TPU training. This involves downloading and running a setup script.

```bash
    # Step 1: Install Torch-XLA (PyTorch with Accelerated Linear Algebra (XLA) support)
    !curl https://raw.githubusercontent.com/pytorch/xla/master/contrib/scripts/env-setup.py -o pytorch-xla-env-setup.py
    !python pytorch-xla-env-setup.py --version nightly --apt-packages libomp5 libopenblas-dev

    # Step 2: Run your PyTorch code
    TPUs (TPU v3-8) have 8 cores, and each core is itself an XLA device.  
    You can run code on a single XLA device, but to take full advantage of 
    the TPU you will want to run your code on all 8 cores simultaneously. 
    For examples that demonstrate how to do this, you can refer to 
    The Ultimate PyTorch TPU Tutorial,
    I Like Clean TPU Training Kernels and I Can Not Lie,
    Super Duper Fast PyTorch TPU Kernel,
    and  XLM Roberta Large Pytorch TPU 


```

--------------------------------

### Install R Package from GitHub using devtools

Source: https://www.kaggle.com/docs/notebooks

Load the devtools package and then use install_github to install R packages directly from GitHub repositories. Requires 'Internet' to be enabled.

```r
library(devtools)
install_github("some_user/some_package")
```

--------------------------------

### Example Solution CSV Format

Source: https://www.kaggle.com/docs/competitions-setup

Illustrates the required format for the solution CSV file, including the ID, target feature, and usage type.

```csv
id,target_feature,Usage
0,1,Public
1,0,Private
2,1,Ignored
```

--------------------------------

### JSON File Example

Source: https://www.kaggle.com/docs/datasets

An example of a JSON file structure for hierarchical data. JSON is suitable for nested data and is displayed as an interactive tree in the Kaggle data explorer.

```json
[{'id': 0, 'type': 'bananas', 'quantity': 12}, {'id': 1, 'type': 'apples', 'quantity': 7}]
```

--------------------------------

### Example Kaggle Package Structure

Source: https://www.kaggle.com/docs/packages

Illustrates the typical file and directory layout of a Kaggle Package generated using nbdev. This structure helps in understanding how exported code, metadata, and assets are organized.

```text
package/
├── __init__.py
├── core.py
├── kagglehub_requirements.yaml
└── assets/
    └── model.weights
```

--------------------------------

### Example Train CSV Format

Source: https://www.kaggle.com/docs/competitions-setup

Shows the expected format for the training data CSV file, including input features and the target feature.

```csv
input_feature1,input_feature2,target_feature
100,52.12,1
192,203.2,1
```

--------------------------------

### TPU Strategy Scope Setup

Source: https://www.kaggle.com/docs/tpu

This boilerplate code demonstrates how to connect to a TPU and instantiate a distribution strategy. Models must be instantiated within this strategy's scope for TPU operations.

```python
# connect to a TPU and instantiate a distribution strategy
tpu = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='local')
tf.tpu.experimental.initialize_tpu_system(tpu)
tpu_strategy = tf.distribute.TPUStrategy(tpu)

# instantiate the model in the strategy scope
with tpu_strategy.scope():
    model = tf.keras.Sequential( … )

```

--------------------------------

### List Supported Models in Kaggle Benchmarks

Source: https://www.kaggle.com/docs/benchmarks

Run this Python command within a task notebook to get a list of currently available models for testing against in Community Benchmarks.

```python
import kaggle_benchmarks as kbench
# returns the current list of available models to test against
list(kbench.llms.keys())
```

--------------------------------

### Offline Pip Install using Dependency Manager

Source: https://www.kaggle.com/docs/notebooks

Configure notebooks for offline pip installs via the Dependency Manager editor. This is useful for internet-disabled competitions.

```python
pip install my-new-package
```

--------------------------------

### Install Python Package using Pip

Source: https://www.kaggle.com/docs/notebooks

Use this command in a code cell to install Python packages with pip. Ensure 'Internet' is enabled in the Notebook settings.

```python
!pip install my-new-package
```

--------------------------------

### Configure Steps Per Execution for TPU Optimization

Source: https://www.kaggle.com/docs/tpu

This example shows how to use the `steps_per_execution` parameter in `model.compile()` to send multiple batches to the TPU at once, reducing communication overhead and improving XLA compiler optimization.

```python
model.compile( … ,
              steps_per_execution=32)
```

--------------------------------

### Start Authorization Flow

Source: https://www.kaggle.com/docs/oauth-provider-api

Redirect users to Kaggle's authorization endpoint to initiate the OAuth2 flow. Ensure to include your client ID, redirect URI, requested scopes, and PKCE parameters if applicable.

```http
GET https://www.kaggle.com/api/v1/oauth2/authorize
```

--------------------------------

### CSV File Example

Source: https://www.kaggle.com/docs/datasets

A simple CSV representation of a shopping list with a header row. CSV is the best-supported format for tabular data on Kaggle.

```csv
id,type,quantity
0,bananas,12
1,apples,7
```

--------------------------------

### Generate PKCE Challenge

Source: https://www.kaggle.com/docs/oauth-provider-api

Generate a PKCE code verifier and challenge for public clients before starting the authorization flow. This involves creating a random verifier and then hashing it with SHA-256.

```python
import secrets
import hashlib
import base64

# Generate a random code_verifier (43-128 characters)
code_verifier = secrets.token_urlsafe(32)

# Create code_challenge using SHA-256
code_challenge = base64.urlsafe_b64encode(
    hashlib.sha256(code_verifier.encode()).digest()
).decode().rstrip('=')
```

--------------------------------

### Start Authorization Flow

Source: https://www.kaggle.com/docs/oauth-provider-api

Redirect users to this endpoint to initiate the OAuth2 authorization process. This endpoint requires several query parameters to identify the client and specify the desired scopes.

```APIDOC
## GET https://www.kaggle.com/api/v1/oauth2/authorize

### Description
Initiates the OAuth2 authorization flow by redirecting the user to Kaggle's consent screen.

### Method
GET

### Endpoint
https://www.kaggle.com/api/v1/oauth2/authorize

### Parameters
#### Query Parameters
- **client_id** (string) - Required - Your registered client ID
- **redirect_uri** (string) - Required - Must match a registered redirect URI
- **scope** (string) - Required - Space-separated list of scopes
- **state** (string) - Required - Random string (20-128 chars) for CSRF protection
- **response_type** (string) - Required - Must be "code"
- **response_mode** (string) - Required - Must be "query"
- **code_challenge** (string) - Optional* - Base64URL-encoded SHA-256 hash of code_verifier. Required for public clients.
- **code_challenge_method** (string) - Optional* - Must be "S256". Required for public clients.

*Required for public clients. Must not be sent by organization clients.
```

--------------------------------

### Initialize BigQuery Client

Source: https://www.kaggle.com/docs/notebooks

Use this snippet to set up a BigQuery client for querying data within Kaggle Notebooks. Ensure your Google Cloud project ID is correctly set.

```python
# Set your own project id here  
PROJECT_ID = 'your-google-cloud-project'  
from google.cloud import bigquery  
bigquery_client = bigquery.Client(project=PROJECT_ID)
```

--------------------------------

### Offline Pip Install from GitHub using Dependency Manager

Source: https://www.kaggle.com/docs/notebooks

Install packages from GitHub offline using the Dependency Manager by providing the git+https URL. This is useful for internet-disabled competitions.

```python
pip install git+https://github.com/author/package.git
```

--------------------------------

### Initialize AutoML Client

Source: https://www.kaggle.com/docs/notebooks

Set up an AutoML client for training custom machine learning models. Ensure the COMPUTE_REGION is set to 'us-central1' as required by AutoML.

```python
# Set your own project id and compute region here  
PROJECT_ID = 'your-google-cloud-project'  
COMPUTE_REGION = 'us-central1'  # must be `us-central1` to use AutoML (see docs)  
from google.cloud import automl_v1beta1 as automl  
automl_client = automl.AutoMlClient()  
project_location = automl_client.location_path(PROJECT_ID, COMPUTE_REGION)
```

--------------------------------

### Initialize Google Cloud Storage Client

Source: https://www.kaggle.com/docs/notebooks

This code initializes a Google Cloud Storage client. Remember to replace 'your-google-cloud-project' with your actual project ID.

```python
# Set your own project id here  
PROJECT_ID = 'your-google-cloud-project'  
from google.cloud import storage  
storage_client = storage.Client(project=PROJECT_ID)
```

--------------------------------

### get_competition_leaderboard

Source: https://www.kaggle.com/docs/mcp

Get the leaderboard for a competition.

```APIDOC
## GET /get_competition_leaderboard

### Description
Get the leaderboard for a competition.

### Method
GET

### Endpoint
/get_competition_leaderboard

### Parameters
#### Query Parameters
- **competition_name** (string) - Required - Competition name.
- **override_public** (bool) - Optional - By default we return the private leaderboard if it's available, otherwise the public LB. This flag lets you override to get public even if private is available.
- **page_size** (int32) - Optional - Page size, i.e., maximum number of results to return.
- **page_token** (string) - Optional - Page token.

### Response
#### Success Response (200)
- **submissions** (repeated ApiLeaderboardSubmission)
- **next_page_token** (string)

### Response Example
{
  "submissions": [
    {
      "team_id": "int32",
      "team_name": "string",
      "submission_date": "google.protobuf.Timestamp",
      "score": "string"
    }
  ],
  "next_page_token": "string"
}
```

--------------------------------

### get_competition

Source: https://www.kaggle.com/docs/mcp

Get competition metadata.

```APIDOC
## GET /get_competition

### Description
Get competition metadata.

### Method
GET

### Endpoint
/get_competition

### Parameters
#### Query Parameters
- **competition_name** (string) - Required - The name of the competition.

### Response
#### Success Response (200)
- **id** (int32)
- **ref** (string)
- **title** (string)
- **url** (string)
- **description** (string)
- **organization_name** (string)
- **organization_ref** (string)
- **category** (string)
- **reward** (string)
- **tags** (repeated ApiCategory)
- **deadline** (google.protobuf.Timestamp)
- **kernel_count** (int32)
- **team_count** (int32)
- **user_has_entered** (bool)
- **user_rank** (int32)
- **merger_deadline** (google.protobuf.Timestamp)
- **new_entrant_deadline** (google.protobuf.Timestamp)
- **enabled_date** (google.protobuf.Timestamp)
- **max_daily_submissions** (int32)
- **max_team_size** (int32)
- **evaluation_metric** (string)
- **awards_points** (bool)
- **is_kernels_submissions_only** (bool)
- **submissions_disabled** (bool)
- **thumbnail_image_url** (string)
- **host_name** (string)

### Response Example
{
  "id": "int32",
  "ref": "string",
  "title": "string",
  "url": "string",
  "description": "string",
  "organization_name": "string",
  "organization_ref": "string",
  "category": "string",
  "reward": "string",
  "tags": [
    {
      "ref": "string",
      "name": "string",
      "description": "string",
      "full_path": "string",
      "competition_count": "int32",
      "dataset_count": "int32",
      "script_count": "int32",
      "total_count": "int32"
    }
  ],
  "deadline": "google.protobuf.Timestamp",
  "kernel_count": "int32",
  "team_count": "int32",
  "user_has_entered": "bool",
  "user_rank": "int32",
  "merger_deadline": "google.protobuf.Timestamp",
  "new_entrant_deadline": "google.protobuf.Timestamp",
  "enabled_date": "google.protobuf.Timestamp",
  "max_daily_submissions": "int32",
  "max_team_size": "int32",
  "evaluation_metric": "string",
  "awards_points": "bool",
  "is_kernels_submissions_only": "bool",
  "submissions_disabled": "bool",
  "thumbnail_image_url": "string",
  "host_name": "string"
}
```

--------------------------------

### Add Kaggle MCP Server using Gemini CLI

Source: https://www.kaggle.com/docs/mcp

Use this command to add the Kaggle MCP server via the Gemini CLI. Ensure the transport is set to http.

```bash
gemini mcp add --transport http kaggle https://www.kaggle.com/mcp
```

--------------------------------

### get_competition_submission

Source: https://www.kaggle.com/docs/mcp

Get metadata about a competition submission.

```APIDOC
## GET /get_competition_submission

### Description
Get metadata about a competition submission.

### Method
GET

### Endpoint
/get_competition_submission

### Parameters
#### Query Parameters
- **ref** (int32) - Required - SubmissionId.

### Response
#### Success Response (200)
(Submission metadata)

### Response Example
(Submission metadata)
```

--------------------------------

### get_competition_data_files_summary

Source: https://www.kaggle.com/docs/mcp

Get a summary of the data files for a competition.

```APIDOC
## GET /get_competition_data_files_summary

### Description
Get a summary of the data files for a competition.

### Method
GET

### Endpoint
/get_competition_data_files_summary

### Parameters
#### Query Parameters
- **competition_name** (string) - Required - The name of the competition.

### Response
#### Success Response (200)
(ApiFilesSummary object)
```

--------------------------------

### Get Model Variation Metadata

Source: https://www.kaggle.com/docs/mcp

Fetches metadata for a specific model variation (instance).

```APIDOC
## Get Model Variation Metadata

### Description
Retrieves metadata about a specific model variation (instance).

### Method
GET (Assumed based on operation name 'get_model_variation', actual HTTP method not specified)

### Endpoint
(Endpoint not specified in source)

### Parameters
#### Request Body
- **owner_slug** (string) - Required - The slug of the owner of the model.
- **model_slug** (string) - Required - The slug of the model.
- **framework** (ModelFramework) - Required - Specifies the model framework. Possible values include: MODEL_FRAMEWORK_UNSPECIFIED, MODEL_FRAMEWORK_TENSOR_FLOW_1, MODEL_FRAMEWORK_TENSOR_FLOW_2, MODEL_FRAMEWORK_TF_LITE, MODEL_FRAMEWORK_TF_JS, MODEL_FRAMEWORK_PY_TORCH, MODEL_FRAMEWORK_JAX, MODEL_FRAMEWORK_FLAX, MODEL_FRAMEWORK_PAX, MODEL_FRAMEWORK_MAX_TEXT, MODEL_FRAMEWORK_GEMMA_CPP, MODEL_FRAMEWORK_GGML, MODEL_FRAMEWORK_GGUF, MODEL_FRAMEWORK_CORAL, MODEL_FRAMEWORK_SCIKIT_LEARN, MODEL_FRAMEWORK_MXNET, MODEL_FRAMEWORK_ONNX, MODEL_FRAMEWORK_KERAS, MODEL_FRAMEWORK_TRANSFORMERS, MODEL_FRAMEWORK_API, MODEL_FRAMEWORK_OTHER, MODEL_FRAMEWORK_TENSOR_RT_LLM, MODEL_FRAMEWORK_TRITON.
- **instance_slug** (string) - Required - The slug of the model instance.

### Response
#### Success Response (200)
- **ApiModelInstance** - Contains detailed information about the model instance.
```

--------------------------------

### Get Model Metadata

Source: https://www.kaggle.com/docs/mcp

Fetches metadata for a specific model, including its details and instances.

```APIDOC
## Get Model Metadata

### Description
Retrieves metadata about a specific model.

### Method
GET (Assumed based on operation name 'get_model', actual HTTP method not specified)

### Endpoint
(Endpoint not specified in source)

### Parameters
#### Request Body
- **owner_slug** (string) - Required - The slug of the owner of the model.
- **model_slug** (string) - Required - The slug of the model.

### Response
#### Success Response (200)
- **ApiModel** - Contains detailed information about the model, including its instances.
```

--------------------------------

### CreateBenchmarkTaskFromPromptRequest

Source: https://www.kaggle.com/docs/mcp

Creates a new benchmark task from a natural language prompt.

```APIDOC
## create_benchmark_task_from_prompt

### Description
Create a new benchmark task from a prompt.

### Parameters
#### Request Body
- **prompt** (string) - Required - A natural language prompt describing the benchmark task to be created.

### Response
#### Success Response (200)
- **task** (BenchmarkTask) - The benchmark task that was created.
  - **id** (int32)
  - **type** (BenchmarkTaskType) - The type of the benchmark task. Possible values: `BENCHMARK_TASK_TYPE_UNSPECIFIED`, `BENCHMARK_TASK_TYPE_BENCHMARK`.
  - **version** (BenchmarkTaskVersion)
    - **id** (int32)
    - **task_id** (int32)
    - **version_number** (int32)
    - **name** (string)
    - **description** (string)
    - **display_type** (BenchmarkLeaderboardDisplayType)
    - **definition** (string)
    - **source_kernel_session_id** (int32)
    - **aggregation_type** (BenchmarkTaskVersionAggregationType)
    - **child_task_versions** (repeated BenchmarkTaskVersion)
    - **parent_task_version_ids** (repeated int32)
    - **is_public** (bool)
    - **owner_user** (kaggle.users.UserAvatar)
    - **type** (BenchmarkTaskType)
    - **permissions** (Permissions)
    - **update_time** (google.protobuf.Timestamp)
    - **definition_type** (BenchmarkTaskDefinitionType) - The definition type of the benchmark task. Possible values: `BENCHMARK_TASK_DEFINITION_TYPE_UNSPECIFIED`, `NOTEBOOK`, `PROMPTFOO`.
    - **owner_user_id** (int32)
    - **owner_user** (kaggle.users.UserAvatar)
    - **source_kernel_id** (int32)
    - **slug** (string)
    - **vote_count** (int32)
    - **has_up_voted** (bool)
    - **forum_id** (int32)
    - **is_public** (bool)
    - **permissions** (Permissions)
      - **can_administer** (bool)
  - **categories** (kaggle.tags.TagList)
    - **tags** (repeated kaggle.tags.Tag)
      - **id** (int32)
      - **name** (string)
      - **type** (kaggle.tags.TagType)

### Request Example
{
  "prompt": "Create a benchmark task to evaluate language models on summarization."
}

### Response Example
{
  "task": {
    "id": 1,
    "type": "BENCHMARK_TASK_TYPE_BENCHMARK",
    "version": {
      "id": 101,
      "task_id": 1,
      "version_number": 1,
      "name": "Summarization Benchmark v1",
      "description": "Evaluating summarization capabilities.",
      "display_type": "DEFAULT",
      "definition": "...",
      "source_kernel_session_id": 123,
      "aggregation_type": "AVERAGE",
      "child_task_versions": [],
      "parent_task_version_ids": [],
      "is_public": true,
      "owner_user": {
        "displayName": "User Name",
        "userName": "username"
      },
      "type": "BENCHMARK_TASK_TYPE_BENCHMARK",
      "permissions": {
        "can_administer": true
      },
      "update_time": "2023-10-27T10:00:00Z",
      "definition_type": "NOTEBOOK",
      "owner_user_id": 1,
      "owner_user": {
        "displayName": "User Name",
        "userName": "username"
      },
      "source_kernel_id": 456,
      "slug": "summarization-benchmark-v1",
      "vote_count": 5,
      "has_up_voted": true,
      "forum_id": 789,
      "is_public": true,
      "permissions": {
        "can_administer": true
      }
    },
    "categories": {
      "tags": [
        {
          "id": 1,
          "name": "NLP",
          "type": "CATEGORY"
        }
      ]
    }
  }
}
```

--------------------------------

### Kaggle MCP Server Configuration (Claude Desktop)

Source: https://www.kaggle.com/docs/mcp

Configuration for Claude Desktop to connect to Kaggle MCP using npx and token authentication.

```json
    {
  "mcpServers": {
     "kaggle": {
      "command": "npx",
      "args": [
          "mcp-remote",
          "https://www.kaggle.com/mcp",
          "--header",
          "Authorization: Bearer YOUR_TOKEN"
      ]
    }
  }
}


```

--------------------------------

### Configure Kaggle MCP Server in Gemini settings.json

Source: https://www.kaggle.com/docs/mcp

Add this JSON configuration to your ~/.gemini/settings.json file to set up the Kaggle MCP server. This specifies the httpUrl for the server.

```json
{
      "mcpServers": {
        "kaggle": {
          "httpUrl": "https://www.kaggle.com/mcp"
        }
      }
    }
```

--------------------------------

### Load TFRecord Dataset from GCS

Source: https://www.kaggle.com/docs/tpu

Loads a dataset from TFRecord files stored on Google Cloud Storage. This is a basic setup for TPU training data.

```python
# On Kaggle you can also use KaggleDatasets().get_gcs_path() to obtain the GCS path of a Kaggle dataset
filenames = tf.io.gfile.glob("gs://flowers-public/tfrecords-jpeg-512x512/*.tfrec") # list files on GCS
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # TFRecord decoding here...
    
```

--------------------------------

### Download Benchmark Leaderboard via cURL (Authenticated)

Source: https://www.kaggle.com/docs/benchmarks

Use this cURL command to download benchmark leaderboard data when the benchmark is private. Requires exporting Kaggle username and API key as environment variables.

```bash
# Authenticated example
# Export your Kaggle username and API key
# export KAGGLE_USERNAME=
# export KAGGLE_KEY=

curl -L -u $KAGGLE_USERNAME:$KAGGLE_KEY \
  -o ~/Downloads/myusername_my-benchmark_leaderboard.json \
  https://www.kaggle.com/api/v1/benchmarks/myusername/my-benchmark/leaderboard
```

--------------------------------

### GET OAuth Protected Resource Metadata

Source: https://www.kaggle.com/docs/oauth-provider-api

Retrieve metadata about the protected resource, which in this case is the Kaggle API. This helps clients understand the capabilities of the resource server.

```HTTP
GET https://www.kaggle.com/.well-known/oauth-protected-resource
```

--------------------------------

### download_competition_leaderboard

Source: https://www.kaggle.com/docs/mcp

Download the leaderboard for a competition.

```APIDOC
## GET /download_competition_leaderboard

### Description
Download the leaderboard for a competition.

### Method
GET

### Endpoint
/download_competition_leaderboard

### Parameters
#### Query Parameters
- **competition_name** (string) - Required - The name of the competition.

### Response
#### Success Response (200)
Returns a file download object.

### Response Example
(FileDownload object)
```

--------------------------------

### Scale Batch Size with TPU Replicas

Source: https://www.kaggle.com/docs/tpu

This code demonstrates how to dynamically set the batch size based on the number of available TPU replicas, ensuring optimal utilization of TPU cores.

```python
BATCH_SIZE = 16 * tpu_strategy.num_replicas_in_sync
```

--------------------------------

### Download Kaggle Model via Wget

Source: https://www.kaggle.com/docs/models

Use wget to download a specific Kaggle model variation, providing authentication directly in the command. This method is suitable for models that do not have restricted licenses.

```bash
# Download specific version (here version 1)
wget https://www.kaggle.com/api/v1/models/google/gemma/pyTorch/2b/1/download --user=$KAGGLE_USERNAME --password=$KAGGLE_KEY --auth-no-challenge
```

--------------------------------

### Run Docker Container

Source: https://www.kaggle.com/docs/packages

Run a Docker container for a Kaggle Package. This ensures the package has the same system dependencies and runs in a sandboxed environment. Replace `gcr.io/...` with the correct image tag.

```bash
docker run -it --rm \
  gcr.io/... \
  /bin/bash
```

--------------------------------

### GET OAuth 2.0 Server Metadata

Source: https://www.kaggle.com/docs/oauth-provider-api

Retrieve OAuth 2.0 server metadata, including supported endpoints, grant types, and scopes. This is a standard discovery endpoint for OAuth 2.0 servers.

```HTTP
GET https://www.kaggle.com/.well-known/oauth-authorization-server
```

--------------------------------

### download_competition_data_files

Source: https://www.kaggle.com/docs/mcp

Download all data files for a competition.

```APIDOC
## GET /download_competition_data_files

### Description
Download all data files for a competition.

### Method
GET

### Endpoint
/download_competition_data_files

### Parameters
#### Query Parameters
- **competition_name** (string) - Required - Competition name.

### Response
#### Success Response (200)
Returns a URL to download the files.

### Response Example
(HTTP Redirect)
```

--------------------------------

### Kaggle MCP Server Configuration (VS Code)

Source: https://www.kaggle.com/docs/mcp

Configuration for VS Code to connect to Kaggle MCP using HTTP and token authentication.

```json
"servers": {
  "kaggle": {
    "url": "https://www.kaggle.com/mcp",
    "type": "http",
      "headers" : {
      "authorization": "Bearer YOUR_TOKEN"
	}	
	}
}


```

--------------------------------

### Loading a TPU Model from Local Disk

Source: https://www.kaggle.com/docs/tpu

When loading a model from local disk onto a TPU, use `tf.saved_model.LoadOptions` with `experimental_io_device='/job:localhost'` within the strategy scope. This directs the load operation to the local machine.

```python
with strategy.scope():
    load_locally = tf.saved_model.LoadOptions(experimental_io_device='/job:localhost')
    model = tf.keras.models.load_model('./model', options=load_locally) # loading in Tensorflow's "SavedModel" format

```

--------------------------------

### Configure Kaggle MCP Server for Claude Desktop

Source: https://www.kaggle.com/docs/mcp

This JSON configuration is used for Claude Desktop. It specifies the command and arguments to run the mcp-remote client for the Kaggle MCP server.

```json
{
  "mcpServers": {
     "kaggle": {
      "command": "npx",
      "args": [
          "mcp-remote",
          "https://www.kaggle.com/mcp"
      ]
    }
  }
}
```

--------------------------------

### Kaggle MCP Server Configuration (Gemini CLI)

Source: https://www.kaggle.com/docs/mcp

Configuration for the Gemini CLI to connect to Kaggle MCP using HTTP transport and token authentication.

```json
"mcpServers": {
    "kaggle": {
      "transport": "http",
      "httpUrl": "https://www.kaggle.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  },

```

--------------------------------

### create_code_competition_submission

Source: https://www.kaggle.com/docs/mcp

Submit a kernel to a competition.

```APIDOC
## create_code_competition_submission

### Description
Submit a kernel to a competition.

### Method
POST

### Endpoint
`/competitions/{competitionId}/submissions`

### Parameters
#### Path Parameters
- **competitionId** (string) - Required - The ID of the competition.

#### Request Body
- **kernelId** (string) - Required - The ID of the kernel to submit.

### Request Example
{
  "kernelId": "your-kernel-id"
}

### Response
#### Success Response (200)
- **submissionId** (string) - The ID of the created submission.

#### Response Example
{
  "submissionId": "your-submission-id"
}
```