Knowledge Catalog (formerly Dataplex), is an AI-powered data catalog and metadata management platform. It provides a dynamic knowledge graph of all your data, structured and unstructured, to provide semantics and business context to AI agents
This repository features tools, agents, and samples that demonstrate Knowledge Catalog features, and building context management, enrichment and retrieval solutions.
Open Knowledge Format (OKF), an open specification that formalizes the LLM-wiki pattern into a portable, interoperable format. This is a vendor-neutral, agent- and human-friendly standard for representing the metadata, context, and curated knowledge that modern AI systems need.
As published, OKF v0.1 represents knowledge as a directory of markdown files with YAML frontmatter, with a small set of agreed-upon conventions that let wikis written by different producers be consumed by different agents without translation.
That's it. No complex compression scheme, no new runtime, no required SDK. A bundle of OKF documents is:
Just markdown — readable in any editor, renderable on GitHub, indexable by any search tool
Just files — shippable as a tarball, hostable in any git repo, mountable on any filesystem
Just YAML frontmatter — for the small set of structured fields that need to be queryable: type, title, description, resource, tags, and timestamp
If you've used Obsidian, Notion, Hugo, or any of the LLM wiki patterns that have emerged over the past year, the shape will feel familiar. OKF formalizes the small set of conventions needed to make these patterns interoperable.
Let’s take a look at the problem that OKF can solve for your organization, how it works, how to get started with it, and what’s next.
Ollama’s Pro, Max, and Team plans now use transparent per-token pricing. Based on your feedback, every plan includes a monthly pool of usage credits.
very plan includes:
High-performance access to the latest open models, at published per-token rates
Works with popular coding agents, including Claude Code and Codex, plus an API for your own tools
Monthly usage credits included with every plan
Zero data retention, hosted in the US and Europe, plus Singapore for a limited set of Qwen models
No service fees or hidden limits
New plans
Ollama’s new Pro, Max, and Team plans include a pool of usage credits that refreshes every month. Usage is consumed per token, at the rates published on Ollama’s pricing page and on each model’s page.
Pro: $20/month, includes $60 of monthly usage
Max: $100/month, includes $300 of monthly usage
Team: $500/month, includes $1,000 of shared monthly usage for unlimited users
The free plan now includes a small amount of monthly usage for a set of starter models. Add usage credits to access all models on the free plan with pay-as-you-go pricing: no service fees, no subscription required.
No hidden fees or limits
Ollama’s new pricing has no service fees and no 5-hour or weekly limits. Each plan’s monthly pool refreshes automatically, and when you use it up, you can keep going at the same per-token rate.
Every request runs on dedicated compute in the US and Europe, plus Singapore for a limited set of Qwen models, with zero data retention. We don’t log your prompts, and we never train on your data. You can see exactly what each request cost in your account.
Team plan is now available
Ollama’s Team plan is now available for signup with introductory pricing of $500/month:
$1,000 of shared included monthly usage, at published per-token rates
One pool of usage credits shared across your organization with no per-seat limits
Invite unlimited users, and view everyone’s usage in one place
* **`MAX_MODEL_LEN="32767"`**: Sets the maximum token context window (prompts plus generated answers) the engine will handle. Restricting this to 32,767 tokens instead of the native ultra-large context (like 256K) drastically reduces the GPU memory required by the KV cache, allowing for higher concurrency and faster boot times.
* **`QUANTIZATION_TYPE="fp8"`**: Specifies 8-bit floating-point (FP8) precision for the model weights. This compresses the size of the model down significantly, cutting memory usage roughly in half and accelerating inference speed with minimal loss in model intelligence.
* **`KV_CACHE_DTYPE="fp8"`**: Compresses the Key-Value (KV) cache storage into FP8 format instead of standard FP16/BF16. Because the KV cache grows rapidly with long conversations, this halves its memory footprint, freeing up space to hold more concurrent users and longer contexts.
* **`GPU_MEM_UTIL="0.95"`**: Tells vLLM to claim and lock down **95%** of the total available GPU VRAM on your Cloud Run instance. The remaining 5% is left as breathing room for PyTorch operations and context switching to prevent out-of-memory (OOM) crashes.
* **`TENSOR_PARALLEL_SIZE="1"`**: Determines how many GPUs the model is split across. Set to `1` because your Cloud Run service instance is provisioned with a single GPU, meaning the entire model runs on that single card.
* **`MAX_NUM_SEQS="16"`**: Caps the maximum number of simultaneous sequences (requests) vLLM will batch and process together in a single step [cite: . This prevents memory spikes under heavy web traffic by queuing excess incoming chat requests.
The output is like below
ravi_retheesh@cloudshell:~ (gemmabigquerymcp)$ gcloud builds submit --project="${GOOGLE_CLOUD_PROJECT}" --region="${GOOGLE_CLOUD_REGION}" --no-source \
substitutions="_MODEL_NAME=${MODEL_NAME},_GCS_MODEL_LOCATION=${GCS_MODEL_LOCATION}" \
--config=/dev/stdin <<'EOF'
steps:
- name: 'gcr.io/google.com/cloudsdktool/google-cloud-cli:slim'
entrypoint: 'bash'
args:
- '-c'
- |
if [[ "$_GCS_MODEL_LOCATION" == *"vertex-model-garden-public-us"* ]]; then
echo "Using the public cache bucket."
exit 0
fi
gcloud config set storage/parallel_composite_upload_enabled True
gcloud config set storage/parallel_composite_upload_threshold 150M
gcloud config set storage/sliced_object_download_threshold 150M
MODEL_NAME="$_MODEL_NAME"
SHORT_NAME="$${MODEL_NAME#*/}"
gcloud storage cp -r -D "gs://vertex-model-garden-public-us/gemma4/$${SHORT_NAME}" "$_GCS_MODEL_LOCATION"
EOF
Created [https://cloudbuild.googleapis.com/v1/projects/gemmabigquerymcp/locations/us-central1/builds/21faa182-824e-42fb-b292-d4368222d847].
Logs are available at [ https://console.cloud.google.com/cloud-build/builds;region=us-central1/21faa182-824e-42fb-b292-d4368222d847?project=593821728960 ].
Waiting for build to complete. Polling interval: 1 second(s).
----------------------------- REMOTE BUILD OUTPUT ------------------------------
starting build "21faa182-824e-42fb-b292-d4368222d847"
FETCHSOURCE
BUILD
Pulling image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
slim: Pulling from google.com/cloudsdktool/google-cloud-cli
6310eb16bf42: Pulling fs layer
488f94d8fb5f: Pulling fs layer
4f4fb700ef54: Pulling fs layer
3cbf6ceea8d8: Pulling fs layer
8421ab9bea9a: Pulling fs layer
488f94d8fb5f: Verifying Checksum
488f94d8fb5f: Download complete
8421ab9bea9a: Verifying Checksum
8421ab9bea9a: Download complete
4f4fb700ef54: Verifying Checksum
4f4fb700ef54: Download complete
6310eb16bf42: Verifying Checksum
6310eb16bf42: Download complete
6310eb16bf42: Pull complete
488f94d8fb5f: Pull complete
4f4fb700ef54: Pull complete
3cbf6ceea8d8: Verifying Checksum
3cbf6ceea8d8: Download complete
3cbf6ceea8d8: Pull complete
8421ab9bea9a: Pull complete
Digest: sha256:14026c08cf391812086012d6c5f14078221ce1b46be0df419f7f31ec9f69c712
Status: Downloaded newer image for gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
Updated property [storage/parallel_composite_upload_enabled].
Updated property [storage/parallel_composite_upload_threshold].
Updated property [storage/sliced_object_download_threshold].
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/README.md to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/README.md
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/chat_template.jinja to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/chat_template.jinja
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/config.json to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/config.json
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/generation_config.json to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/generation_config.json
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/model-00001-of-00002.safetensors to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/model-00001-of-00002.safetensors
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/model-00002-of-00002.safetensors to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/model-00002-of-00002.safetensors
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/model.safetensors.index.json to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/model.safetensors.index.json
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/processor_config.json to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/processor_config.json
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/tokenizer.json to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/tokenizer.json
Copying gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it/tokenizer_config.json to gs://gemmabigquerymcp-us-central1-hf-model-cache/model-cache/google/gemma-4-31B-it/tokenizer_config.json
Yes, hanging at this point is completely expected.
What you are looking at in your terminal output is the script successfully copying the smaller configuration files (README.md, tokenizers, json configs), and it has now reached the heavy .safetensors files.
What is happening internally?
Massive File Sizes: The Gemma 4 31B model consists of multi-gigabyte weight tensors split across multiple large files (e.g., model-00001-of-00002.safetensors and model-00002-of-00002.safetensors), each weighing anywhere from 10 GB to 15 GB+ depending on the quantization.
Silent Progress: The standard gcloud storage cp command does not stream a granular, incremental progress bar inside a Cloud Build remote execution log. Because it is processing a massive file payload over the network in total silence, the terminal appears completely frozen.
Is it actually working?
Yes. As long as the build hasn't timed out or thrown an explicit error, the Cloud Build worker is actively pulling the file blocks from Google's public model garden bucket and streaming them into your custom GCS cache bucket (gemmabigquerymcp-us-central1-hf-model-cache).
What should you do?
Wait it out: Depending on network routing inside the us-central1 data center, a multi-gigabyte copy can take anywhere from 2 to 10 minutes.
Verify via Console (Optional): If you want to check if data is actually transferring, you can open a separate Cloud Shell tab and run a check on your destination bucket to see file sizes growing:
Bash
gcloud storage du -s "gs://${MODEL_CACHE_BUCKET}"
Let it run for a few more minutes; it will finish and proceed to the next step once the tensor files are fully copied over.
**Yes, this snippet is very good and standard practice** for handling large open-weights models like Gemma 4 on serverless infrastructure like Cloud Run.
### How This Works and Why It's Designed This Way
* **Bypassing Cloud Build Limits:** Cloud Build has strict storage limits and timeouts. Trying to download a massive 30GB+ model inside a standard build step or pushing it straight into a container image will typically break or exceed size thresholds.
* **Leveraging Google's Public Cache (`vertex-model-garden-public-us`):** Google hosts public copies of model weights inside specialized regional GCS buckets. If your Cloud Run service runs in a `us-` region, the snippet intelligently skips downloading entirely (`exit 0`), allowing your app to stream weights straight from Google’s ultra-fast internal network.
* **Parallel Upload Optimization:** If you are using a non-US region or deploying a custom fine-tuned variant, the `gcloud config set storage/...` commands configure parallel composite uploads and sliced downloads. This breaks large model safetensors files into chunks, downloading them concurrently to bypass single-stream bottlenecks.
---
### Your Options to Run Gemma 4 on Google Cloud Run
When deploying Gemma 4 (such as the 31B Dense or 26B MoE variants) to Cloud Run, you have two primary deployment architectures:
| Approach | Architecture | Best For |
| --- | --- | --- |
| **1. vLLM Container + GCS Cache (The Snippet Method)** | Packages vLLM inside a custom container image, pulls weights directly from GCS into GPU memory using high-performance streaming. | High throughput, production-grade OpenAI-compatible API serving, and maximum token generation speed. |
| **2. Ollama on Cloud Run** | Deploys an Ollama runtime container to Cloud Run backed by serverless GPUs, pulling model weights dynamically on start. | Lightweight setups, rapid prototyping, and simpler configuration files. |
Both approaches require provisioning **NVIDIA RTX Pro 6000 (Blackwell)** or similar serverless GPUs on Cloud Run to supply enough VRAM to hold the model weights.
This command creates a dedicated Google Cloud Storage (GCS) bucket to act as a staging cache for your large AI model weights.
Why is this step performed?
Bypassing Hugging Face Rate Limits / Slowdowns: Downloading massive multi-gigabyte open-weights models directly from Hugging Face every time a Cloud Run container spins up is slow and prone to network timeouts or rate limits.
Optimizing Cold Starts with vLLM: When combined with the Run:ai Model Streamer feature built into vLLM, the container can stream model weight tensors concurrently and directly from GCS into GPU memory.
This drastically minimizes container boot-up and model-loading times.
Direct VPC Egress: Keeping the bucket in the same single region as your Cloud Run service ensures data flows privately and rapidly over Google's internal network rather than traversing the public internet.
Does Google by default provide a vLLM runtime?
No, Google Cloud does not provide a pre-installed, managed vLLM runtime service out of the box (like a native managed-vllm API endpoint).
Instead, Google provides the underlying infrastructure to run vLLM yourself:
Compute Support: Cloud Run supports attaching high-performance GPUs (such as NVIDIA L4 or RTX Pro 6000) and Google Cloud TPUs, alongside serverless scaling.
Bring-Your-Own-Container (BYOC): To use vLLM on Cloud Run, you package vLLM inside a custom container image (or use open-source deep learning containers/Buildpacks) that pulls the model weights from your GCS bucket upon startup and exposes an OpenAI-compatible API endpoint.
