LLM batch 2 pages

static/deployment.md

@@ -0,0 +1,117 @@
+# Deployment — LLM Guidance
+
+## TL;DR
+
+Weaviate deployment options map closely to pricing plans and infrastructure control levels.
+
+| Option | Infra model | Typical plan |
+|---|---|---|
+| **Shared (multi-tenant)** | Weaviate-managed | Free Trial / Flex |
+| **Dedicated** | Isolated infrastructure | Premium |
+| **BYOC** | Your VPC, Weaviate-operated | Premium (enterprise setups) |
+| **Self-managed** | Fully user-operated | Open-source |
+
+---
+
+## When to use Serverless Cloud (shared)
+
+- Building and prototyping; no infrastructure to provision
+- Pay-as-you-go consumption pricing (charged per stored vector/object)
+- Teams that want managed upgrades, scaling, and monitoring out of the box
+- Applications that can tolerate shared multi-tenant infrastructure
+- Fastest path from zero to a working Weaviate cluster
+
+For more detail: https://weaviate.io/deployment/shared.md
+
+---
+
+## When to use Enterprise Cloud (dedicated)
+
+- Production workloads requiring predictable, isolated performance
+- Compliance or security review processes that require dedicated hardware
+- High-throughput or low-latency targets incompatible with shared tenancy
+- Enterprise procurement requirements (isolation boundaries, SLA guarantees)
+- Teams ready to move off prototyping infra; usage patterns are stable
+
+For more detail: https://weaviate.io/deployment/dedicated.md
+
+---
+
+## When to use Bring Your Own Cloud (BYOC)
+
+- Your organisation mandates that data stays in your own cloud account / VPC
+- You need private networking (no public endpoints)
+- You want Weaviate to operate the cluster but retain cloud account ownership
+- Data residency regulations require you to control where data physically lives
+
+BYOC setup: your VPC hosts the data plane; Weaviate manages the control plane and provides 24/7 monitoring and support.
+
+---
+
+## When not to use this page
+
+This is a decision guide. Once you have chosen a deployment type, go to the specific twin page for that option:
+
+- Serverless / Shared: https://weaviate.io/deployment/shared.md
+- Dedicated / Enterprise Cloud: https://weaviate.io/deployment/dedicated.md
+- BYOC: https://weaviate.io/deployment/byoc (detailed page, contact sales)
+- Self-managed: https://docs.weaviate.io/weaviate/installation
+
+---
+
+## Quickstart
+
+All Weaviate Cloud options (Serverless, Enterprise, BYOC) use the same client connection method. Only the cluster URL changes.
+
+```python
+import os
+import weaviate
+
+with weaviate.connect_to_weaviate_cloud(
+    cluster_url=os.environ["WEAVIATE_URL"],
+    auth_credentials=os.environ["WEAVIATE_API_KEY"],
+) as client:
+    print(client.get_meta())
+```
+
+For self-managed (local or on-prem):
+
+```python
+import weaviate
+
+with weaviate.connect_to_local() as client:
+    print(client.get_meta())
+```
+
+---
+
+## Common gotchas
+
+**"I chose Serverless but now need dedicated performance."**
+Clusters can be migrated. Contact Weaviate support or use the Weaviate Cloud Console to request an upgrade to Enterprise Cloud. Data migration tooling is available.
+
+**"BYOC vs self-managed — what's the difference?"**
+BYOC: Weaviate operates the software in your VPC (you own the cloud account, Weaviate manages the cluster). Self-managed: you install, upgrade, and operate Weaviate yourself using the open-source software.
+
+**"Does the client library change between deployment types?"**
+No. `connect_to_weaviate_cloud()` works for Serverless, Enterprise Cloud, and BYOC. `connect_to_local()` is for self-managed.
+
+**"Are there SLA differences?"**
+Yes. Serverless has Standard SLA. Enterprise Cloud offers Professional and Business Critical SLAs. Self-managed has no Weaviate SLA (open-source BSD3 license). See https://weaviate.io/service for details.
+
+**"Can I use my committed spend discount on BYOC?"**
+Check your contract. Committed discounts do not automatically apply to BYOC clusters — confirm with your Weaviate account team.
+
+---
+
+## Canonical links
+
+- Deployment overview: https://weaviate.io/deployment
+- Serverless detail: https://weaviate.io/deployment/serverless
+- Enterprise Cloud detail: https://weaviate.io/deployment/enterprise-cloud
+- BYOC detail: https://weaviate.io/deployment/byoc
+- Pricing: https://weaviate.io/pricing
+- SLA tiers: https://weaviate.io/service
+- Security checklist (self-managed): https://weaviate.io/img/site/Security-Checklist.pdf
+- Installation docs (self-managed): https://docs.weaviate.io/weaviate/installation
+- Client libraries: https://docs.weaviate.io/weaviate/client-libraries

static/javascript.md

@@ -0,0 +1,63 @@
+# JavaScript — LLM Guidance
+
+## TL;DR
+- Use the official JavaScript/TypeScript client package: weaviate-client.
+- Typical flow in Node: connect, create or open a collection, ingest objects, then query.
+- Hybrid search is a strong default for user-facing retrieval because it mixes semantic and keyword matching.
+- Use Weaviate Cloud for managed setup, or local Docker for development and tests.
+- Keep API keys in environment variables and avoid hardcoding credentials.
+
+## When to use
+- You are building a Node or TypeScript app that needs semantic search or RAG retrieval.
+- You need filtering plus vector/keyword retrieval in one query path.
+- You want one database layer for objects, vectors, and metadata filters.
+
+## When not to use
+- You only need simple relational transactions and joins; use a relational DB first.
+- You need analytics-heavy OLAP workloads as the primary system.
+- You are not using JavaScript/TypeScript in your app stack.
+
+## Quickstart
+~~~ts
+import weaviate, { vectors } from 'weaviate-client';
+
+const client = await weaviate.connectToWeaviateCloud(
+  process.env.WEAVIATE_URL!,
+  {
+    authCredentials: new weaviate.ApiKey(process.env.WEAVIATE_API_KEY!),
+  }
+);
+
+const exists = await client.collections.exists('Docs');
+if (!exists) {
+  await client.collections.create({
+    name: 'Docs',
+    vectorizers: vectors.text2VecWeaviate(),
+  });
+}
+
+const docs = client.collections.use('Docs');
+await docs.data.insert({
+  title: 'Hybrid search basics',
+  body: 'Hybrid combines BM25 keyword and vector relevance.',
+});
+
+const res = await docs.query.hybrid('how do I use hybrid search in JS?', {
+  limit: 3,
+});
+
+console.log(res.objects.map((o) => o.properties));
+await client.close();
+~~~
+
+## Common gotchas
+- Client version mismatch with server features can cause unexpected errors.
+- Forgetting to close the client can leak resources in long-running jobs.
+- Missing env vars for URL or API key is a common startup failure.
+- If local setup fails, confirm HTTP and gRPC ports are reachable.
+
+## Canonical links
+- Human page: /javascript
+- Docs: https://docs.weaviate.io/weaviate/client-libraries/typescript/typescript-v3
+- Related: /hybrid-search
+- Related: /product/query-agent

static/product-previews.md

@@ -0,0 +1,78 @@
+# Product Previews — LLM Guidance
+
+## TL;DR
+- Product previews are **early-access features** that are still evolving.
+- They are useful for **testing new capabilities**, not for critical production workloads.
+- APIs, behaviour, and availability may change without notice.
+- Access is typically gated via **request or approval**.
+- Do not assume preview features are generally available (GA).
+
+## What are product previews
+Product previews are experimental or early-access features in Weaviate that allow users to test new capabilities before general availability.
+
+They are designed to:
+- Gather feedback from real users
+- Validate performance and usability
+- Iterate quickly before full release
+
+Examples may include:
+- New indexing strategies (e.g. HNSW variants or memory optimisations)
+- Agent-based features (e.g. context/memory systems)
+- Evaluation or tooling workflows
+
+## When to use
+- You want to explore upcoming features before they are fully released
+- You are comfortable with **breaking changes or iteration**
+- You are running internal experiments, PoCs, or demos
+- You want to give feedback to the Weaviate team
+
+## When not to use
+- You need **stable, production-grade guarantees**
+- Your system depends on strict SLAs or compliance requirements
+- You require long-term API stability
+- You cannot tolerate behaviour changes between updates
+
+## Access and expectations
+- Most preview features require **early access requests**
+- Support may be limited compared to GA features
+- SLAs typically do not apply
+- Features may be:
+  - modified significantly
+  - replaced
+  - or removed entirely
+
+## Relationship to core product
+Preview features are separate from:
+- Core database capabilities (search, storage, filtering)
+- Stable product offerings (e.g. Query Agent, embeddings, deployment tiers)
+
+They should be treated as **add-ons or experiments**, not core dependencies.
+
+## Quickstart (example mindset)
+There is no single API for previews — access and usage depend on the specific feature.
+
+Typical flow:
+- Request access
+- Enable feature in your cluster or account
+- Follow feature-specific documentation or guidance
+
+## Common gotchas
+
+- **Assuming preview = production-ready**
+  → Previews are intentionally unstable and evolving
+
+- **Hardcoding preview APIs**
+  → APIs may change without backward compatibility
+
+- **Missing access enablement**
+  → Many features require explicit approval or flags
+
+- **Relying on incomplete docs**
+  → Documentation may lag behind implementation
+
+## Canonical links
+
+- Human page: /product-previews
+- Pricing: /pricing.md
+- Deployment: /deployment.md
+- Related: /product.md

static/product/query.md

@@ -0,0 +1,85 @@
+# Query — LLM Guidance
+
+## TL;DR
+- This page is about **core querying in Weaviate**: hybrid search, vector search, keyword search, and filters.
+- Use **hybrid** as the default retrieval strategy for most production apps.
+- Add **filters** (and tenant scoping where relevant) to constrain results to the right slice of data.
+- This is **not** Query Agent. Query Agent is a higher-level agentic layer that plans queries for you.
+
+## When to use
+- You are building direct retrieval logic in application code.
+- You want explicit control over query type (`hybrid`, `near_text`, `bm25`) and filters.
+- You need predictable, testable retrieval behavior for search or RAG.
+- You already know your collection schema and metadata fields.
+
+## When not to use
+- You want natural-language orchestration, cross-collection planning, and automatic query construction.
+  - Use Query Agent instead: https://weaviate.io/product/query-agent.md
+- You only need to click-run ad hoc GraphQL queries in UI.
+  - Use the Query tool in Workbench: https://weaviate.io/product/query
+- You are still deciding query strategy.
+  - Start with hybrid, then evaluate whether pure vector or pure BM25 is better.
+
+## Quickstart (Python)
+```py
+import os
+import weaviate
+from weaviate.classes.query import Filter
+
+with weaviate.connect_to_weaviate_cloud(
+    cluster_url=os.environ["WEAVIATE_URL"],
+    auth_credentials=os.environ["WEAVIATE_API_KEY"],
+) as client:
+    col = client.collections.use("Docs")
+
+    # Hybrid is the recommended default.
+    res = col.query.hybrid(
+        query="how to enable RBAC",
+        filters=Filter.by_property("product").equal("weaviate"),
+        limit=5,
+    )
+
+    for obj in res.objects:
+        print(obj.properties)
+```
+
+## Quickstart (JavaScript optional)
+```js
+import weaviate from 'weaviate-client';
+
+const client = await weaviate.connectToWeaviateCloud(
+  process.env.WEAVIATE_URL,
+  {
+    authCredentials: new weaviate.ApiKey(process.env.WEAVIATE_API_KEY),
+  }
+);
+
+const docs = client.collections.use('Docs');
+
+const result = await docs.query.hybrid('how to enable RBAC', {
+  limit: 5,
+  filters: docs.filter.byProperty('product').equal('weaviate'),
+});
+
+for (const o of result.objects) {
+  console.log(o.properties);
+}
+```
+
+## Common gotchas
+- **Confusing Query with Query Agent**: Query is low-level retrieval APIs; Query Agent is managed agentic query planning.
+- **Using pure vector by default**: start with hybrid for better relevance when users include exact terms and natural language.
+- **Skipping filters**: unfiltered retrieval can return semantically similar but out-of-scope results.
+- **Ignoring tenant boundaries**: in multi-tenant setups, always query the correct tenant.
+- **Comparing scores across query types**: do not assume score scales match between hybrid, vector, and BM25.
+- **Over-fetching**: keep `limit` small for first-pass retrieval, then rerank or refine.
+
+## Canonical links
+- Product Query page: https://weaviate.io/product/query
+- Query Agent twin (different product): https://weaviate.io/product/query-agent.md
+- Hybrid search twin: https://weaviate.io/hybrid-search.md
+- Filtering docs: https://docs.weaviate.io/weaviate/search/filters
+- Hybrid search docs: https://docs.weaviate.io/weaviate/search/hybrid
+- Vector search docs: https://docs.weaviate.io/weaviate/search/similarity
+- Keyword/BM25 docs: https://docs.weaviate.io/weaviate/search/bm25
+- Multi-tenancy docs: https://docs.weaviate.io/weaviate/manage-collections/multi-tenancy