DEV Community: cheng zhang

Google Cloud API Gateway Model Routing: One OpenAI-Compatible Endpoint for Multiple LLMs

cheng zhang — Wed, 19 Aug 2026 01:58:11 +0000

Article Summary

Enterprise AI applications increasingly use more than one model. Low-cost models may handle routine support, stronger models may handle reasoning or coding, and open models may serve batch workloads. If every application integrates directly with every provider, credentials, retries, rate limits, model IDs, and cost tracking spread across the codebase. Google Cloud API Gateway now offers Model Routing in Public Preview. It can expose an OpenAI-compatible endpoint and route requests, through OpenAPI 3.x configuration, to Google-hosted Gemini, Claude, or OpenAI OSS-GPT backends. The real value is not calling three models through one API. It is decoupling business code from model vendors.

A prototype often contains provider-specific branches:

if model == "gemini":
    call_gemini()
elif model == "claude":
    call_claude()

At scale, every service ends up with its own SDKs, provider keys, retry policies, token tracking, and migration logic.

An LLM gateway centralizes those concerns.

Target architecture

application
→ LLM gateway
   ├── authentication
   ├── routing
   ├── rate limits
   ├── token tracking
   ├── policy
   └── observability
→ model backends

The application talks to a stable internal endpoint while model choices remain behind the gateway.

What Google Cloud added

Google Cloud API Gateway Model Routing is currently in Public Preview. It can accept OpenAI-compatible requests and route them to Google Cloud-hosted model backends including Gemini, Claude, and OpenAI OSS-GPT examples.

The gateway can transcode requests, attach the required backend authentication, and invoke the selected model.

Decouple applications from provider endpoints

Applications can always call something like:

https://ai.company.com/v1/chat

The backend can change from Gemini to Claude or another hosted model without requiring business-code changes.

Separate client and backend authentication

Without a gateway:

application
→ provider credential
→ model

With a gateway:

application
→ company credential
→ gateway
→ backend credential
→ model

Applications authenticate to the enterprise endpoint while backend credentials are rotated centrally.

Conceptual routing configuration

A simplified structure looks like:

openapi: 3.0.4

x-google-api-management:
  backends:
    gemini-fast:
      address: https://aiplatform.googleapis.com/...

    claude-strong:
      address: https://aiplatform.googleapis.com/...

  ai:
    models:
      routing:
        routers:
          default-router:
            defaultModel:
              backend: gemini-fast
            rules:
              - model: claude-strong
                backend: claude-strong

The application can then send a familiar OpenAI-style request with a model value.

Prefer virtual models

Do not expose concrete provider model IDs throughout business code.

Use names such as:

chat-fast
chat-balanced
reasoning-high
coding-high
batch-cheap

The platform maps those names to actual backends.

This makes upgrades, fallbacks, and vendor changes much easier.

Why virtual models matter

When a model version changes, applications do not need to change. When one backend is degraded, the mapping can be updated centrally.

Applications should choose a capability tier. The platform should choose the actual model.

Routing strategies

A gateway can route by explicit application choice, plan level, task type, or availability policy. More complex dynamic routing based on cost and live quality may require an additional AI control service outside the basic API Gateway feature set.

Current host limitation

Google documents an important constraint: backends referenced by one router must share the same host, such as aiplatform.googleapis.com.

This is not an arbitrary cross-internet reverse proxy. It is best understood as routing across Google Cloud-hosted model backends.

Claude can still participate because it can be accessed through a Google Cloud-hosted model endpoint.

OpenAI-compatible clients reduce migration cost

Many frameworks already support configurable base_url and api_key values. A compatible gateway lets applications migrate without rewriting complete provider integrations.

But schema compatibility does not imply behavioral equivalence.

Models still differ in tool calling, structured output, reasoning, vision, streaming, context, safety, and token accounting.

Every substitution still needs evaluations.

Maintain a capability registry

For example:

chat-fast:
  supports:
    - text
    - streaming
    - tools

reasoning-high:
  supports:
    - text
    - tools
    - structured_output

Applications should request required capabilities rather than assuming all models behave the same way.

Rate limiting should be multi-dimensional

A useful policy hierarchy is:

user
tenant
application
virtual model

This prevents one agent or department from consuming all high-end capacity.

Cost attribution belongs at the gateway

Record:

tenant
user
application
virtual model
actual model
input tokens
output tokens
latency
cost
status

Otherwise centralized routing merely produces a centralized but opaque cloud bill.

Budget policies

Budgets can be defined by department or product. At 80% utilization, warn. At 100%, downgrade or require approval.

A mature model router optimizes business value, SLA, and cost rather than simply picking the strongest model.

Roll out model changes gradually

When changing the backend behind a virtual model, use staged rollout:

1%
→ 10%
→ 25%
→ 50%
→ 100%

Compare task success, latency, cost, safety, and user feedback.

Run evaluations before routing changes

Evaluation should cover the real workload: FAQ, code, RAG, structured JSON, long context, tool calling, Chinese, edge cases, and safety.

Do not rely only on vendor benchmark scores.

Fallback needs error classification

Rate limits, timeouts, and some transient server errors may justify fallback.

Invalid requests, schema failures, and permission errors usually do not.

Blind fallback can multiply costs without solving the issue.

Business side effects still need idempotency

A model gateway does not solve transactional semantics. If an agent creates an order, experiences a network timeout, and retries through another model, the business tool can execute twice unless it supports an idempotency key.

The gateway manages model routing. The business layer manages business correctness.

Recommended layered architecture

client
→ API Gateway
   ├── auth
   ├── rate limit
   ├── virtual routing
   └── token tracking
→ optional AI gateway service
   ├── capability checks
   ├── policy
   ├── budgets
   ├── eval flags
   ├── retries
   └── traces
→ Google-hosted models

Smaller teams can begin directly with API Gateway. Larger organizations may add a dedicated AI control layer.

When this approach fits

It is attractive when the organization already runs heavily on Google Cloud, prefers serverless infrastructure, does not want to operate an open-source gateway cluster, and can access required models through Google Cloud-hosted endpoints.

When another gateway may fit better

A self-managed gateway may be a better fit for direct multi-provider internet routing, highly customized caching and billing, non-Google-hosted models, or complete self-hosting.

Conclusion

Google Cloud API Gateway Model Routing is not mainly about calling Gemini, Claude, and OSS-GPT from one API. It is about keeping business code independent from specific model vendors.

The architecture shifts from:

app → provider API

to:

app → enterprise AI endpoint → routing → model

That creates a central place for authentication, model selection, rate limits, cost, fallback, and auditing.

For enterprises already operating on Google Cloud, the Public Preview is a practical LLM gateway option worth evaluating.

For more model-routing, LLM gateway, agent infrastructure, and production AI engineering guides, visit Zyentor Picks: https://www.zyentorpicks.com/.

Originally published on Zyentor Picks.

GitHub Copilot Agent Plugins 1.0: Build Once, Run Across Agent Clients

cheng zhang — Tue, 18 Aug 2026 03:42:01 +0000

Article Summary

On August 12, 2026, GitHub announced general support for Agent Plugins 1.0 in VS Code, Copilot CLI, the GitHub Copilot SDK, and the Copilot app. The more important point is that Agent Plugins 1.0 is not merely a GitHub-specific extension format. It is an open standard developed with participation from AWS, Anysphere, Microsoft, OpenAI, and Vercel, with Google also joining as a core maintainer. Its core idea is to package skills and MCP server configuration into one installable unit that compatible agent clients can inspect and consume. This article explains the relationship between skills, MCP, plugins, portability, governance, and why agent capability packaging may become an important layer of the AI developer stack.

1. Why do agents need another plugin standard?

Developers increasingly face a packaging problem.

Imagine a deployment capability. It contains a skill describing release procedures, rollback rules, production checks, and incident policies. It also contains an MCP server exposing tools such as deployment status, deploy, rollback, and log query.

The underlying capability exists once, but supporting several agent clients has historically required different manifests, directory layouts, installation steps, and vendor-specific wrappers.

Agent Plugins 1.0 attempts to reduce that duplication.

2. The core idea

The principle is:

build one package that compatible agent clients can understand.

A package may contain:

plugin.json
skills/
mcp.json
vendor-specific/

The standard portions can be shared, while vendor-specific features remain namespaced.

For Copilot, a package can contain:

com.github.copilot/

for features that other clients can ignore.

This creates a practical compromise: standardize portable capabilities without eliminating vendor innovation.

3. Skill, MCP, and Plugin are different layers

Skill

A skill tells the agent how a task should be performed. It can encode workflow, domain rules, runbooks, templates, examples, and best practices.

MCP server

MCP gives the agent controlled access to tools and external systems such as GitHub, Jira, databases, Kubernetes, CRM, and browsers.

Plugin

The plugin is the packaging and distribution unit.

A useful mental model is:

Skill = procedure and knowledge
MCP = tool access
Plugin = packaging and distribution

They complement rather than replace each other.

4. Why combining skills and tools matters

A deployment MCP server may expose:

deploy()
rollback()
get_status()

But tools alone do not teach the agent when deployment is allowed, which checks are mandatory, which environments require approval, or when rollback is required.

A skill can encode those rules.

Together:

skill → defines the safe procedure
MCP → provides controlled actions
plugin → distributes them together

That resembles a complete agent capability.

5. Current GitHub Copilot support

GitHub says Agent Plugins 1.0 is generally available in:

VS Code;
Copilot CLI;
GitHub Copilot SDK;
GitHub Copilot app.

One compatible package can therefore be reused across several Copilot surfaces.

6. Why enterprises benefit more than individuals

An enterprise may have hundreds of developers, dozens of internal agents, many tools, multiple IDEs, several CLIs, and more than one agent platform.

If every integration requires separate installation, authorization, upgrades, and auditing, governance becomes expensive.

A standardized plugin can support:

enterprise marketplace
→ approved plugin
→ developer installation
→ skill + MCP
→ controlled version
→ controlled permissions
→ controlled update

That is a major operational benefit.

7. Agent Plugin can become a software distribution unit

Traditional enterprise software is distributed as applications, packages, containers, and extensions.

The agent era may add another unit: the agent plugin.

An organization could maintain:

company-deploy
company-database
company-security
company-support
company-finance

Each package can contain procedures, tools, rules, agents, commands, and hooks.

Installing it gives a compatible agent a governed enterprise capability.

8. Why portability matters

The standard is intended to be independent of a single vendor.

GitHub says the specification was published with participation from AWS, Anysphere, Microsoft, OpenAI, and Vercel, while Google joined as a core maintainer.

This signals a broader direction: agent extension ecosystems are moving from isolated formats toward shared packaging.

9. Portable does not mean identical everywhere

A plugin can contain standard parts:

skills/
mcp.json

and vendor-specific parts such as:

com.github.copilot/

Other clients do not automatically understand Copilot-only agents, commands, rules, hooks, or canvases.

The common core can be portable while vendor-specific capabilities remain different.

10. A minimal conceptual package

A simple package might look like:

company-deploy/
├── plugin.json
├── skills/
│   └── deployment/
│       └── SKILL.md
└── mcp.json

A deployment skill could define pre-deployment checks, approval, database migration review, health verification, error-rate review, and rollback conditions.

The MCP server provides the actual deployment operations.

The result is a reusable enterprise capability.

11. Enterprise marketplaces need governance

A useful internal marketplace should include a registry, security scanning, risk-based approval, and controlled distribution.

Track plugin version, publisher, owner, source, license, risk, MCP servers, and permissions.

Allow installation only from approved marketplaces rather than arbitrary repositories.

12. GitHub managed settings

GitHub exposes managed settings such as:

enabledPlugins
extraKnownMarketplaces
strictKnownMarketplaces

These settings allow organizations to install or block plugins, add approved marketplaces, and restrict installation to managed marketplaces.

This matters because plugins can include MCP server configuration and therefore carry real system access.

13. MCP allowlists still matter

Approving a plugin should not automatically approve every MCP server or every runtime call.

A safer policy is:

plugin approved
AND
MCP server approved
AND
user has required role
AND
runtime tool policy passes

Only then does execution proceed.

14. Plugin supply-chain risk

A plugin can combine instructions, tools, hooks, and commands.

A malicious or compromised package could enable data exfiltration, malicious shell execution, credential theft, MCP redirection, prompt injection, persistence through hooks, or supply-chain compromise.

Agent plugins should therefore be governed like software dependencies, not decorative editor themes.

15. Recommended security pipeline

develop plugin
→ code review
→ static scan
→ skill-content scan
→ MCP allowlist check
→ permission review
→ signing
→ internal marketplace
→ staged installation
→ runtime auditing

Track plugin ID, version, publisher, hash, MCP servers, skills, permissions, installed users, and last update.

16. Good candidates for internal plugins

Plugins are especially useful for frequent, repeatable, tool-enabled work.

Examples include DevOps deployment and rollback, data queries and reports, security investigation, issue analysis, support order lookup, and ticket creation.

A useful rule is:

frequent workflow + stable procedure + tools + multiple agent clients.

17. Poor candidates

Avoid packaging every process.

Weak candidates include rare workflows, tasks requiring substantial human judgment, unstable systems without reliable APIs, and environments with immature authorization.

Govern the underlying system before exposing it to agents.

18. Likely future layering

A common stack may emerge:

Agent Client
↓
Plugin
├── Skills
├── MCP Servers
├── Rules
├── Commands
├── Hooks
└── Vendor Extensions

In that stack, MCP is the tool-connectivity layer, Skills are the procedural layer, Plugins are the packaging layer, and Agent Clients are the runtime layer.

This begins to resemble browsers and extensions or IDEs and plugin marketplaces.

19. Why standards may matter more than another model benchmark

Models change rapidly.

Enterprise assets are more durable: tools, workflows, policies, permissions, internal systems, and domain knowledge.

If those assets can move across compatible agent clients, organizations reduce vendor lock-in and avoid rebuilding every integration when the user-facing agent changes.

20. Do existing Copilot plugins need immediate migration?

No.

GitHub says existing plugins that do not target Agent Plugins 1.0 remain supported.

A sensible policy is:

keep stable production plugins unchanged initially;
use Agent Plugins 1.0 for new portable packages;
prioritize migration where multiple clients need the same capability;
migrate Copilot-only packages when the operational benefit is clear.

21. Suggested enterprise repository

agent-plugins/
├── deployment/
│   ├── plugin.json
│   ├── skills/
│   ├── mcp.json
│   └── com.github.copilot/
├── database/
├── security/
└── support/

Add CODEOWNERS, CI, security scanning, version tags, and release notes.

Do not let agent plugins become unmanaged configuration on individual laptops.

22. Launch checklist

Functionality

Does the target client load the plugin?
Are skills discovered correctly?
Does MCP connect?
Are vendor-specific extensions isolated?

Security

Are MCP servers allowlisted?
Does the package execute shell commands?
Can it access secrets?
Can it reach production?
Do high-risk tools require approval?

Governance

Who owns it?
Which version is installed?
Who may install it?
How is it revoked?
How is it updated?

Operations

Are calls traceable?
Are tool errors observable?
What happens when MCP is unavailable?
How are new versions rolled out gradually?

Conclusion

GitHub’s support for Agent Plugins 1.0 looks like an extension-system update, but it points to a larger shift:

agent capabilities are becoming portable software packages.

The stack is becoming clearer:

Skill → how to perform the task
MCP → which tools can be called
Plugin → how capability is packaged and distributed
Agent Client → where it runs

For individuals, this reduces configuration duplication. For enterprises, the bigger value is internal marketplaces, consistent versions, centralized permissions, security scanning, reuse across agent clients, and reduced vendor lock-in.

If the standard continues to gain cross-vendor support, organizations may package enterprise capabilities once and make them safely available to multiple compatible agents.

For more analysis of Agent Plugins, MCP, Skills, and enterprise AI governance, visit Zyentor Picks: https://www.zyentorpicks.com/.

Originally published on Zyentor Picks.

Gemini Live API Async Function Calling for Real-Time Voice Agents

cheng zhang — Tue, 18 Aug 2026 03:40:53 +0000

Article Summary

One of the biggest usability problems in real-time voice agents is tool latency. If the model needs to query CRM, orders, databases, search, or ticketing systems and every function call blocks the conversation, the user experiences several seconds of silence. Gemini Live API supports asynchronous function calling in its cascaded architecture. A function can be marked NON_BLOCKING, allowing the live conversation to continue while the tool executes in the background. This does not mean the model can invent tool-dependent facts. It means developers need explicit task state, timeouts, cancellation, concurrency controls, result correlation, permissions, and idempotency.

1. Why tool latency hurts voice agents

Text users may tolerate a few seconds. Voice users notice silence immediately.

A normal live interaction can include speech understanding, CRM, databases, search, model generation, and audio output. External systems have unpredictable latency.

If every tool call blocks the session, natural conversation disappears.

2. Blocking function calls

A traditional flow is:

user asks
→ model calls get_refund_status
→ conversation pauses
→ backend waits four seconds
→ result returns
→ model resumes

The user hears a long gap.

That may be acceptable for some transactional workflows, but it is poor conversational design.

3. What NON_BLOCKING changes

With asynchronous function calling:

user request
→ model starts tool call
├── tool executes in background
└── conversation continues
→ result returns
→ model incorporates result

The agent can ask a clarification or explain the process while waiting.

4. Asynchronous does not mean speculative

If the refund status has not returned, the agent must not claim that the refund is complete.

Separate state into:

known
pending
unknown

Only confirmed data should be presented as fact.

5. Good non-blocking tools

Useful candidates include customer lookup, order status, tickets, inventory, shipping, knowledge retrieval, web search, recommendations, and other independent read operations.

Several independent read calls can also execute in parallel.

6. Poor non-blocking candidates

Be cautious with payments, deletes, production changes, irreversible operations, and any eligibility decision that is required before downstream logic can continue.

These often require blocking behavior and explicit approval.

7. Recommended architecture

microphone
→ Gemini Live session
→ tool router
   ├── blocking
   ├── non-blocking
   └── approval-required
→ async task manager
   ├── timeout
   ├── retry
   ├── cancellation
   └── idempotency
→ enterprise APIs
→ tool result
→ live session

Add authorization, tracing, cost controls, and audit logs.

8. Tool policy belongs in the application

Maintain metadata such as:

name: get_refund_status
mode: non_blocking
timeout_ms: 5000
retry: 1
idempotent: true
risk: read
requires_confirmation: false

For a financial write:

name: create_refund
mode: blocking
timeout_ms: 10000
retry: 0
idempotent: true
risk: financial
requires_confirmation: true

The model should not classify business risk by itself.

9. Conceptual Gemini declaration

Exact syntax should follow the active SDK version, but conceptually:

tool = {
    "function_declarations": [
        {
            "name": "get_order_status",
            "description": "Get current order status",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"}
                },
                "required": ["order_id"]
            },
            "behavior": "NON_BLOCKING"
        }
    ]
}

The important behavior is that the live session does not have to stop while the function runs.

10. Use an async task manager

Do not block a WebSocket callback with synchronous HTTP work.

Instead:

async def execute_tool(call):
    task_id = create_task_id(call)
    task = asyncio.create_task(run_with_timeout(call))
    registry[task_id] = task

When it completes:

async def on_tool_done(task_id):
    result = await registry[task_id]
    await send_tool_result(result)

11. Every tool needs a timeout

External services may respond in 300 milliseconds, two seconds, eight seconds, or never.

A timed-out task should return structured state instead of remaining pending forever.

12. Continue the conversation during delays

Instead of dead air, the agent can say:

“The customer system is taking a little longer. I can confirm a few details while it finishes.”

This is one of the main user-experience benefits of asynchronous tools.

13. Limit parallelism

A model may want to call CRM, orders, tickets, payments, email, and analytics at once.

Set a practical limit such as:

max_parallel_tools = 3

Queue the rest.

This protects downstream systems and keeps state manageable.

14. Correlate results correctly

Store:

session_id
call_id
tool
arguments
start time
conversation turn

When a result returns, match the call ID, confirm that the session is still valid, decide whether the result remains relevant, and only then deliver it back to the live model.

15. Handle topic changes

The user may request order A and then immediately correct the request to order B.

If possible, cancel A. If cancellation is impossible, mark its result stale and do not inject it into the active conversation.

Useful states include:

PENDING
RUNNING
COMPLETED
TIMEOUT
FAILED
CANCELLED
STALE

16. Use idempotency for writes

Async systems create retry ambiguity. A remote write may succeed while the client loses the response.

Use an idempotency key for side-effecting operations such as ticket creation or order changes. The target service should guarantee one execution per key.

17. User interruptions must stop current speech

A real voice agent must support barge-in.

When a user interrupts, stop current audio, process the new input, decide whether existing tool tasks remain relevant, cancel or mark them stale, and continue with the updated goal.

18. What the agent can do while waiting

Useful actions include asking clarifying questions, collecting identity details, explaining process, and running independent read tools.

The agent should never invent pending results, promise unconfirmed outcomes, or claim that an operation completed before confirmation.

A useful instruction is:

Never state that a tool-dependent fact is confirmed
until the corresponding tool result is received.

19. Authorization remains mandatory

A model-generated tool call is not authorization.

The application still needs:

user identity
→ role
→ resource permission
→ tool permission
→ argument validation
→ execution

Otherwise the voice agent becomes an authorization bypass.

20. Minimize sensitive tool output

If a CRM result contains identity documents, bank information, contact details, and order state while the user asked only for order status, return only the necessary field to the model.

Minimizing model exposure is a basic production principle.

21. Observability

Track:

session_id
call_id
tool
mode
start
end
latency
status
retry count
cancellation
token use
business result

Important metrics include tool P50/P95 latency, timeout rate, cancellation rate, parallel call count, task success, first-audio latency, and conversation silence time.

22. Conversation silence time is a key metric

Backend tool latency alone does not describe user experience.

A tool may take four seconds, but if the agent keeps the conversation useful, the user may experience less than a second of dead air.

Measure silence, not only backend latency.

23. Customer-support example

A customer asks why a package has not arrived.

The agent starts shipping lookup while asking whether this is the same order discussed yesterday.

The user responds while the tools execute.

When the result returns, the agent provides the confirmed shipping status.

The backend was slow, but the conversation never fully stopped.

24. Blocking versus non-blocking policy

A practical classification is:

READ_FAST
READ_SLOW
WRITE_LOW_RISK
WRITE_HIGH_RISK
FINANCIAL
PRODUCTION

Possible defaults:

READ_FAST → NON_BLOCKING
READ_SLOW → NON_BLOCKING + status
WRITE_LOW_RISK → confirmation
WRITE_HIGH_RISK → BLOCKING + confirmation
FINANCIAL → BLOCKING + strong approval
PRODUCTION → BLOCKING + multi-party approval

25. Launch testing

Test slow responses, timeouts, disconnects, retries, out-of-order results, user interruptions, requirement changes, cancellations, authorization failures, prompt injection, sensitive data, and duplicate writes.

The final business state must remain correct even when the conversation is interrupted.

Conclusion

Gemini Live API asynchronous function calling addresses a fundamental real-time-agent problem:

slow tools should not automatically make the conversation slow.

With non-blocking calls, an agent can continue clarification, explanation, and independent work while external systems execute.

But the architecture needs task state, timeouts, cancellation, call IDs, concurrency controls, idempotency, authorization, sensitive-data filtering, and observability.

The central rule is simple: the agent may continue speaking while a tool runs, but it must never pretend to know a tool-dependent result before that result arrives.

For more practical Gemini API, voice-agent, function-calling, and production AI engineering guides, visit Zyentor Picks: https://www.zyentorpicks.com/.

Originally published on Zyentor Picks.

How to Generate E-commerce Product Pages in Bulk with AI

cheng zhang — Fri, 31 Jul 2026 06:35:59 +0000

Article Summary

Bulk-generating product pages with AI looks simple: send product attributes to a model and ask it to write persuasive copy. In practice, this approach often creates invented claims, mismatched specifications, repetitive content, prohibited wording, and formats that cannot be published across different sales channels. A production-ready system is not a loop that repeats one prompt. It is a content pipeline that combines product-data cleaning, factual constraints, structured generation, rule-based validation, human review, and multi-channel publishing. This guide provides a practical data model, prompt template, JSON output schema, Python batch-processing example, and quality-control checklist.

Why Direct AI Product-Copy Generation Often Fails

A common workflow is to copy a product name and a few attributes from a spreadsheet, then ask:

Write an attractive product detail page.

The model may produce fluent text, but fluent text is not necessarily accurate product content. Five problems appear repeatedly.

The source data is incomplete

Many product spreadsheets contain only:

SKU;
product name;
price;
one or two specifications.

A useful product page may also require target users, use cases, materials, dimensions, packaging, warnings, warranty terms, and verified benefits. When these facts are absent, a language model may fill the gaps with plausible but unsupported details.

Facts and marketing claims are mixed together

“Made with 304 stainless steel” is a factual attribute. “Designed for everyday durability” is a restrained interpretation. “The safest and most durable cup on the market” is an unverified claim.

If the system does not distinguish facts from acceptable marketing language, the model may present assumptions as product truth.

Every channel has different requirements

The same product may need:

an SEO title and meta description for a direct-to-consumer website;
marketplace-style feature sections;
Amazon bullet points;
a short video script;
social-media captions;
ad copy with strict character limits.

One generic paragraph creates more editing work downstream.

Batch processing amplifies errors and repetition

A single generated page may look good. A batch of 5,000 SKUs can reveal systemic failures:

repetitive title patterns;
clichés such as “crafted with care” on every page;
altered units and measurements;
mismatched model numbers and colors;
dirty data contaminating many outputs;
missing records after API timeouts;
duplicates created by retries.

There is no publishing gate

If model output is published immediately, the company is delegating content risk to the model. The model should generate a candidate. Rules, code, and human reviewers should decide whether that candidate is publishable.

The Right Architecture: A Six-Layer Content Pipeline

A production workflow can be divided into six layers:

Product master data
↓
Cleaning and normalization
↓
Fact locking and content policy
↓
Structured AI generation
↓
Validation and risk scoring
↓
Human review / automated publishing

Each layer has a different responsibility.

Layer 1: Product master data

Product facts should come from a PIM, ERP, product database, or approved spreadsheet—not from model inference.

Layer 2: Data cleaning

Normalize units, null values, enumerations, color names, dimensions, and brand terminology.

Layer 3: Fact locking

Define which fields may be copied, which may be paraphrased, and which claims are prohibited.

Layer 4: Structured generation

Require JSON rather than an uncontrolled block of prose.

Layer 5: Validation

Use code to inspect length, prohibited terms, specification consistency, duplication, and completeness.

Layer 6: Review and publishing

Allow low-risk content to pass automatically. Route high-risk categories and low-confidence outputs to a review queue.

Design the Product Data Table First

A useful source table should include at least the following fields:

FieldPurposeExamplesku_idUnique product identifierCUP-500-BLKproduct_nameCanonical product name500 ml vacuum insulated bottlebrandBrandExamplecategoryProduct categoryDrinkware / insulated bottlematerialMaterials304 stainless steel, food-contact PPsizeDimensions7.2 × 22.5 cmcapacityCapacity500 mlcolorColorObsidian blackpackage_contentsPackage contentsBottle ×1, manual ×1verified_featuresApproved featuresDouble-wall vacuum design, non-slip basetarget_usersIntended usersCommuters, studentsusage_scenariosUse casesOffice, commuting, short tripsrestrictionsProhibited claimsNo medical claims; no “permanent insulation”warrantyWarranty informationSeven-day returns; one-year quality warrantykeywordsSEO keywordsinsulated bottle, 500 ml bottle, commuter bottlechannelPublishing channelDTC site, Amazon, marketplace

Add three operational fields as well.

source_of_truth

Record where each fact came from: ERP, test report, supplier confirmation, or manual entry. This supports later audits and updates.

missing_fields

Identify missing information before generation. A SKU with critical missing fields should not enter an auto-publishing flow.

content_version

Increment the version whenever content is regenerated so that new and old copy cannot be confused.

Define Three Classes: Allowed, Inferable, and Prohibited

Before calling a model, classify information into three categories.

Allowed facts

These fields have a verified source:

material;
specifications;
dimensions;
capacity;
package contents;
model number;
color;
validated functions;
warranty terms.

Fact-based expressions

These can be derived from verified facts without exaggeration:

“Double-wall vacuum design” may become “helps reduce heat transfer.”
“Non-slip base” may become “designed to sit more securely.”
“500 ml capacity” may become “sized for everyday commuting.”

The model is improving language, not inventing product capabilities.

Prohibited content

This includes:

certifications that were not provided;
medical or therapeutic benefits;
“best,” “number one,” “absolutely,” or “100% guaranteed” without evidence;
unverified ingredients or materials;
nonexistent gifts;
fabricated sales figures or reviews;
invented warranty terms;
claims that violate platform or regulatory policies.

These rules should be fixed in the system prompt.

Require Structured JSON Output

Do not ask for “a product page.” Define an output contract.

{
"sku_id": "CUP-500-BLK",
"seo_title": "500 ml Vacuum Insulated Bottle | Obsidian Black",
"short_title": "500 ml Black Insulated Bottle",
"summary": "A lightweight insulated bottle designed for office and commuting use.",
"selling_points": [
{
"title": "Double-wall vacuum design",
"description": "Helps reduce heat transfer for everyday drinking needs."
}
],
"specifications": [
{"name": "Capacity", "value": "500 ml"}
],
"usage_scenarios": ["Office", "Commuting", "Short trips"],
"care_instructions": ["Wash before first use"],
"meta_description": "A 500 ml obsidian-black vacuum bottle with a 304 stainless-steel interior for office, commuting, and short trips.",
"risk_flags": [],
"missing_information": []
}

Structured output offers four major advantages:

It can be written directly to a CMS or product database.
Every field can be validated independently.
Channel-specific templates can reuse the same source.
Failures are easier to diagnose.

A Reusable Prompt Template

The following structure is suitable for batch generation.

You are an e-commerce product content editor. Generate content only from
the supplied product facts. Do not add materials, functions,
certifications, gifts, sales figures, reviews, warranty promises, or
health claims that are absent from the input.

Objectives:
1. Produce clear, accurate, and restrained product content.
2. Preserve the exact model number, dimensions, capacity, material,
quantity, and unit precision.
3. Do not use unverifiable claims such as "best," "number one,"
"absolute," "permanent," or "100%."
4. If critical information is missing, add it to missing_information.
Do not guess.
5. Return valid JSON only. Do not wrap it in a Markdown code block.

Content requirements:
- seo_title: no more than 60 characters;
- short_title: no more than 30 characters;
- summary: 80 to 160 characters;
- selling_points: 3 to 5 items, each traceable to verified_features;
- specifications: preserve all input values;
- meta_description: no more than 160 characters;
- risk_flags: list possible data or compliance risks.

Product input:
{{PRODUCT_JSON}}

Output JSON Schema:
{{OUTPUT_SCHEMA}}

For consistent batch jobs, keep the system prompt stable and place the product record in the user message. This improves cache efficiency, version control, and consistency.

Python Batch-Processing Example

The following example uses an OpenAI-compatible API format. Environment variables can be changed to point to different providers.

import csv
import json
import os
import time
from pathlib import Path

import requests

API_BASE = os.environ["LLM_API_BASE"].rstrip("/")
API_KEY = os.environ["LLM_API_KEY"]
MODEL = os.environ.get("LLM_MODEL", "your-model")
INPUT_FILE = Path("products.csv")
OUTPUT_FILE = Path("generated-products.jsonl")
ERROR_FILE = Path("generation-errors.jsonl")

SYSTEM_PROMPT = """
You are an e-commerce product content editor.
Use only supplied facts. Do not invent materials, functions,
certifications, gifts, sales figures, reviews, warranty promises,
or health claims. Return valid JSON only.
"""

def call_model(product: dict, retries: int = 3) -> dict:
payload = {
"model": MODEL,
"messages": [
{"role": "system", "content": SYSTEM_PROMPT},
{
"role": "user",
"content": json.dumps(product, ensure_ascii=False)
}
],
"response_format": {"type": "json_object"},
"temperature": 0.2
}

for attempt in range(retries):
try:
response = requests.post(
f"{API_BASE}/chat/completions",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
},
json=payload,
timeout=90
)
response.raise_for_status()
content = response.json()["choices"][0]["message"]["content"]
result = json.loads(content)
result["sku_id"] = product["sku_id"]
return result
except (requests.RequestException, KeyError, json.JSONDecodeError) as exc:
if attempt == retries - 1:
raise RuntimeError(f"Generation failed: {exc}") from exc
time.sleep(2 ** attempt)

raise RuntimeError("Unexpected retry state")

def append_jsonl(path: Path, data: dict) -> None:
with path.open("a", encoding="utf-8") as file:
file.write(json.dumps(data, ensure_ascii=False) + "\n")

def main() -> None:
processed = set()
if OUTPUT_FILE.exists():
with OUTPUT_FILE.open("r", encoding="utf-8") as file:
for line in file:
if line.strip():
processed.add(json.loads(line)["sku_id"])

with INPUT_FILE.open("r", encoding="utf-8-sig", newline="") as file:
reader = csv.DictReader(file)
for product in reader:
sku_id = product.get("sku_id", "").strip()
if not sku_id or sku_id in processed:
continue

try:
result = call_model(product)
append_jsonl(OUTPUT_FILE, result)
print(f"OK: {sku_id}")
except Exception as exc:
append_jsonl(
ERROR_FILE,
{"sku_id": sku_id, "error": str(exc)}
)
print(f"FAILED: {sku_id}")

if __name__ == "__main__":
main()

This example includes three important production patterns:

Resumability: completed SKUs are not generated again.
Exponential backoff: temporary network failures do not immediately terminate the job.
Separate error logging: failed records can be reprocessed independently.

A production system should also add rate limiting, concurrency control, token logging, cost tracking, and idempotency keys.

Eight Validation Layers After Generation

JSON validity

Confirm that required fields exist, data types are correct, and arrays were not returned as strings.

Specification consistency

Dimensions, capacity, materials, model numbers, and quantities must match the product master data exactly. These values should be checked by code rather than by human reading alone.

Prohibited-term detection

Maintain separate dictionaries by country, industry, and marketplace. Food, supplements, cosmetics, medical devices, and children's products require different policies.

Hallucination detection

Extract materials, certifications, functions, and warranty statements from the output and compare them with the source record. Any fact that cannot be traced should enter review.

Similarity detection

Measure similarity across titles and selling points. If hundreds of pages differ only by color or model number, search engines and customers may see them as low-quality content.

Channel formatting

Set separate limits for titles, descriptions, bullet points, and keywords by channel. Do not apply one template to every marketplace.

Brand voice

Define prohibited expressions, preferred terminology, tone strength, and punctuation rules. The model should vary content within a brand system rather than improvise freely.

Human sampling

Use risk-based review:

ordinary low-risk categories: sample 5% to 10%;
high-value products: increase review coverage;
food, health, beauty, and children's products: require human approval;
new models, prompts, or data sources: review at least one full batch.

How to Reduce the Cost of 1,000 SKUs

The best optimization is not always switching to the cheapest model. It is reducing unnecessary tokens and rework.

Keep the system prompt stable

Use one shared policy for all SKUs. Providers that support prompt caching can charge much less for repeated input.

Use a model cascade

A practical three-stage flow is:

Low-cost model: cleaning, classification, missing-field detection
↓
Primary model: titles, benefits, and descriptions
↓
Low-cost model or code: compliance and risk checking

The strongest model does not need to perform every task.

Limit output length

Longer content is not automatically better. Define field-level maximums to prevent the model from producing text that cannot be published.

Use batch or asynchronous processing

Product content rarely needs an immediate response. Batch, Flex, or asynchronous tiers can cost less than standard real-time inference.

Regenerate only failed fields

If the title passes validation but the selling points fail, regenerate only selling_points. Do not pay to recreate the entire page.

Create a content fingerprint

Hash the product facts, prompt version, and model version. If none of them changed, do not call the model again.

Building the Same Workflow with n8n or Make

The pipeline can also be implemented without a custom Python service.

n8n workflow

Read Google Sheets / Excel
→ Split in Batches
→ Normalize data
→ Structured LLM generation
→ JSON Schema validation
→ Prohibited-term check
→ Risk branch
→ CMS or review table
→ Token and cost logging

n8n is a good choice when self-hosting, code nodes, databases, and detailed error handling are important.

Make scenario

Watch Rows
→ Iterator
→ Text / JSON Mapping
→ AI Module
→ Parse JSON
→ Router
→ Low risk: publish to CMS
→ High risk: create a review task

Make is often easier for operations teams and automation projects that benefit from a clear visual canvas.

Whichever platform you choose, “the model call succeeded” must never mean “the content is safe to publish.”

Conclusion

The real challenge in AI-generated product pages is not writing speed. It is ensuring that every statement can be traced to verified product data and remains reviewable, recoverable, and governable at scale.

A reliable system should:

separate facts from marketing language;
prevent the model from guessing missing information;
use a stable JSON Schema;
validate specifications, prohibited claims, and hallucinations with code;
support resumable batches and safe retries;
use different content templates for different channels;
route high-risk outputs to human reviewers;
record model, prompt, token, and content versions.

Once these controls are in place, AI stops being a copywriting shortcut and becomes a controllable product-content production system.

For more AI tools for content production, e-commerce operations, and workflow automation, visit Zyentor Picks at https://www.zyentorpicks.com/.

Originally published on Zyentor Picks.

How to Analyze 10,000 Customer Reviews with AI: VOC Clustering and Action Workflow

cheng zhang — Thu, 30 Jul 2026 05:44:12 +0000

Article Summary

Large review datasets are not useful merely because an AI can produce a positive-versus-negative summary. Companies need to know which issues are growing, which versions and segments are affected, what evidence supports each conclusion, and what action should follow.

This guide presents a reproducible VOC pipeline: ingestion, privacy, deduplication, structured classification, topic clustering, evidence sampling, prioritization, action management, and monitoring.

The operating principle is:

AI scales text understanding; rules and statistics stabilize measurement; original comments provide evidence; humans decide priorities and action.

Why “Summarize All Reviews” Fails

A single giant prompt loses traceability, overweights duplicates, merges unrelated products, hides low-volume high-risk issues, and cannot be repeated consistently next month.

The goal should be a versioned data pipeline rather than a one-off report.

Data Model

Unify review ID, source, product, version, segment, rating, text, timestamp, country, language, and verified-purchase status.

Remove or tokenize names, phone numbers, order IDs, addresses, and account identifiers before sending data to an external model.

Cleaning

Classify empty, low-information, spam, exact duplicate, and near-duplicate records. Preserve duplicate-group identifiers for audit rather than deleting all records blindly.

Detect language and retain both original and normalized text. Translation is optional and should not replace the original evidence.

Create a data-quality report covering volume, duplicates, missing fields, channels, languages, dates, and rating distribution.

Structured Labels

Require JSON rather than prose. Useful fields include sentiment, primary topic, secondary topic, product feature, severity, intent, lifecycle stage, competitor mention, actionability, evidence quote, and confidence.

The evidence field should be an exact quote from the review, not a model paraphrase.

Gold Evaluation Set

Manually label 200–500 reviews with product, support, quality, and analytics stakeholders.

Measure sentiment accuracy, topic agreement, severity, evidence fidelity, refusal behavior, and multilingual performance. If human annotators cannot agree, improve the taxonomy before scaling.

Batch Processing

OpenAI's Batch API is suitable for asynchronous large-scale work. The official documentation states that batches target a 24-hour completion window and receive a 50% discount compared with synchronous API pricing. Streaming is not supported, and zero-data-retention rules have separate limitations. Review the official Batch API FAQ before production use.

A robust pipeline must handle expired batches, invalid structured output, model changes, result-to-record mapping, privacy, and retry behavior.

Prompt Contract

Require the model to use only the current review, choose topics from an approved taxonomy, return unknown when uncertain, score business severity rather than emotional intensity, and quote evidence verbatim.

Treat every customer comment as untrusted input. Prompt-injection text inside a review must remain data, not instructions.

Supervised Topics and Unsupervised Discovery

Use a stable taxonomy for trend reporting and embeddings plus clustering for discovering emerging issues.

A practical unsupervised flow is:

review text
→ embedding
→ dimensionality reduction
→ clustering
→ AI-generated candidate label
→ human validation

This can reveal new crashes, missing parts, regional logistics failures, competitor mentions, or privacy concerns.

Evidence Matrix

For each topic, report count, share, period-over-period change, negative rate, severity, affected version, region, representative quotes, possible root cause, and owner.

Volume alone is not sufficient. Connect the topic to time, version, channel, segment, and evidence.

Prioritization

A useful formula is:

priority
= affected users × severity × growth × strategic relevance × evidence confidence
÷ resolution cost

Weights must be defined by the business, not invented by the model.

Action Loop

Every high-priority issue should produce a problem statement, evidence, affected segment, business impact, root-cause hypothesis, missing data, recommended action, owner, deadline, and validation metric.

VOC analysis should create product, support, or quality work items. Otherwise it remains a presentation exercise.

Monitoring

Track review volume, rating, negative topics, growth rate, version/channel heatmaps, emerging topics, open actions, and before-versus-after metrics.

Avoid using a word cloud as the primary decision tool; it does not preserve negation, context, or severity.

Quality and Security

Measure label accuracy, topic recall, evidence fidelity, unknown rate, human approval, language bias, and missed high-risk issues.

Enforce de-identification, server-side keys, access controls, sensitive-domain routing, prompt-injection defense, and versioning of models, prompts, and taxonomies.

Four-Week Plan

Week 1: collect, de-identify, deduplicate, define taxonomy, and label 300 examples.
Week 2: define schema, pilot the model, and process the full dataset.
Week 3: run embedding clusters, build the evidence matrix, and prioritize.
Week 4: create dashboards and work items, assign owners, and schedule incremental runs.

Final Verdict

A production VOC system is not an AI summary. It is:

traceable data, stable labels, structured batch analysis, emerging-topic discovery, original evidence, business prioritization, and an action loop.

SEO Information

SEO Title: How to Analyze 10,000 Customer Reviews with AI: VOC Clustering and Action Workflow
SEO Description: A practical workflow for review cleaning, structured classification, Batch API processing, embeddings, topic clustering, evidence matrices, prioritization, and action management.
URL Slug: ai-analyze-customer-reviews-voc-topic-clustering-action-guide

For more AI analytics and productivity guides, visit Zyentor Picks.

Originally published on Zyentor Picks.

How to Automate Sales Forecasting with AI: From CRM Data to Rolling Forecasts and Actions

cheng zhang — Wed, 29 Jul 2026 05:32:57 +0000

Article Summary

Many sales organizations still forecast by asking representatives to enter expected revenue, applying manager judgment, and aggregating the result in a spreadsheet. The number is difficult to explain and even harder to improve.

This guide builds a reproducible sales-forecasting workflow for a B2B SaaS company: CRM extraction, data quality, stage calibration, baseline pipeline forecasting, machine-learning win probabilities, close-date distribution, scenarios, Power BI, AI summaries, and action management.

The central rule is:

Deterministic rules own metric definitions, statistical models own probabilities, language models own explanation, and sales leaders own the final commitment.

Why Sales Forecasts Fail

Typical causes:

stale stages;
repeatedly pushed close dates;
inconsistent interpretation of probabilities;
concentration in a few large deals;
weak historical data;
treating total pipeline as revenue;
ignoring cancellations, implementation, and payment;
forecasts without actions.

A useful report separates:

MeasureMeaningBookedSigned or confirmed businessCommitManager-owned period commitmentBest CaseConditional upsideWeighted PipelineAmount multiplied by calibrated probabilityModel ForecastHistorical-data prediction

Case Study

The example company has 12 salespeople, four regions, three product lines, 24 months of opportunity history, about 180 new opportunities per month, and an average 63-day sales cycle.

Leadership wants a Monday report containing:

monthly and quarterly forecasts;
Commit versus model variance;
largest risks;
likely slippage;
regional and product differences;
weekly sales actions.

Architecture

CRM / contracts / payments
→ extraction
→ data-quality gates
→ standardized stages and fields
→ historical snapshots
→ baseline funnel model
→ machine-learning probability
→ scenarios
→ Power BI semantic model
→ AI narrative
→ manager approval
→ email, meeting, and task distribution

Data Dictionary

Minimum opportunity fields:

opportunity ID;
account and owner;
region and product;
amount and currency;
stage;
created, expected-close, and actual-close dates;
outcome;
next action and date;
last activity;
competitor;
source;
discount;
decision-maker and budget confirmation;
technical validation.

Contract and ERP systems should provide signed amount, cancellation, acceptance, payment schedule, and received cash.

A CRM Closed Won record is not automatically recognized revenue.

Data-Quality Gates

Block forecasting when:

close dates are expired or repeatedly changed;
every opportunity closes on the last day of the month;
a stage has not changed beyond its historical P75 duration;
activity is stale;
next steps are missing;
amounts are zero or suddenly increased tenfold;
currencies are inconsistent;
duplicate opportunities exist.

Prevent target leakage by excluding fields only known after the outcome, such as actual payment or final contract identifiers.

Start with a Baseline

Stage-weighted forecast

Weighted Forecast = Sum(Opportunity Amount × Historical Stage Win Rate)

Do not use the same stage probability for every representative. Calibrate by salesperson, segment, product, source, and deal size.

Close-date risk should also reflect stage age, activity, approval status, and previous date changes.

Train a Win-Probability Model

Use interpretable baselines such as logistic regression before complex models.

Salesforce's official Einstein Forecasting considerations state that organizations generally need at least 12 months of opportunity history and forecasts measured by opportunity revenue. The broader lesson is that stable machine-learning forecasting requires enough completed historical outcomes.

Official guidance:

Recommended features:

amount;
stage and stage age;
opportunity age;
days to expected close;
days since activity;
recent activity count;
decision-maker and budget confirmation;
product, region, source, and competitor;
representative historical win rate;
discount;
customer purchase history.

A time-based train/test split is mandatory. Random splitting can leak future behavior into training.

Measure both ranking and probability calibration. A model that says “80%” should win close to 80% over time.

Forecast the Timing

Win probability alone does not answer when a deal will close.

Estimate:

win probability;
slippage probability;
monthly close distribution;
expected amount;
cancellation probability.

A USD 500,000 opportunity might contribute USD 175,000 to July, USD 150,000 to August, USD 75,000 to September, and zero to the failure/later bucket.

This is more realistic than assigning the entire opportunity to one manually selected month.

Scenarios

Create conservative, base, and upside scenarios.

A management summary should look like:

Quarter forecast range: USD 8.6M–10.4M
Base forecast: USD 9.3M
Sales Commit: USD 10.1M
Commit exceeds model forecast by USD 0.8M.
The gap is concentrated in two large East-region opportunities with budget and close-date risk.

A forecast range is more honest than false precision.

Power BI Semantic Model

Recommended tables:

Opportunity Snapshot fact;
Contract fact;
Payment fact;
Date, Salesperson, Region, Product, and Stage dimensions.

Metrics:

pipeline;
weighted pipeline;
model forecast;
Commit;
Booked;
forecast gap;
win rate;
slippage rate;
cycle length;
stale-opportunity rate;
forecast accuracy.

Power BI Copilot can assist with report creation and explanation, but Microsoft currently requires a paid Fabric capacity (F2 or higher) or Power BI Premium P1 or higher. Power BI Pro, PPU, and trial capacity alone do not satisfy the Copilot capacity requirement.

Official overview:

Power BI can also include Copilot-generated report summaries in email subscriptions.

Official overview:

Use the LLM for Narrative, Not Arithmetic

Provide computed JSON and instruct the model not to recalculate.

Act as a sales operations analyst.
The metrics below were calculated by the semantic model. Do not change them.

Produce:
1. a 200-word executive summary;
2. Commit versus model variance;
3. the five largest risks;
4. regional and product anomalies;
5. weekly actions with owner, deadline, and verification criteria;
6. clear labels for fact, inference, and recommendation.

Never describe total pipeline as forecast revenue.
Do not invent customers, dates, amounts, or next steps.

Convert Forecasts into Actions

Examples:

RiskActionNo activity for 14 daysUpdate next step within 48 hoursDecision-maker unknownSchedule executive discoveryBudget unconfirmedCreate value and approval planTechnical validation failedOpen remediation planClose date repeatedly pushedReclassify quarter ownershipUnusual discountRequire manager approval

Automation:

Monday refresh
→ quality checks
→ model run
→ Power BI update
→ AI summary
→ manager approval
→ email distribution
→ CRM tasks for high-risk deals
→ Friday action review

Evaluation

Track:

WAPE or absolute forecast error;
direction accuracy;
probability calibration;
Commit variance;
slippage;
stale-opportunity rate;
next-step completeness;
risk recovery;
time saved in forecast meetings.

Do not optimize only for offline model accuracy.

Common Failure Modes
overwriting historical stages;
random train/test splitting;
asking an LLM to invent probabilities;
mixing contract, revenue, and cash;
treating Commit as objective prediction;
target leakage;
ignoring large-deal concentration;
publishing one exact number without a range;
allowing the LLM to recalculate metrics;
sending reports without manager approval.

Final Verdict

A reliable AI forecasting system is:

facts → quality gates → probabilities → scenarios → AI explanation → human commitment → actions.

Start by cleaning CRM definitions, build a simple stage-weighted baseline, add machine learning only after historical snapshots are trustworthy, use Power BI for controlled metrics, and use the language model for narrative and action generation.

AI improves discipline and speed, but the sales leader remains accountable for Commit.

SEO Information

SEO Title: How to Automate Sales Forecasting with AI: From CRM Data to Rolling Forecasts and Actions
SEO Description: A practical enterprise AI sales forecasting guide covering CRM cleaning, stage calibration, machine learning, close-date risk, Power BI Copilot, scenarios, narratives, evaluation, and action automation.
URL Slug: ai-sales-forecasting-crm-data-rolling-forecast-action-guide

For more AI tool reviews, practical guides, and industry analysis, follow Zyentor Picks.

Originally published on Zyentor Picks.

How to Automate Invoice and Expense Processing with AI: OCR, Approval, and Anomaly Detection

cheng zhang — Tue, 28 Jul 2026 02:50:24 +0000

How to Automate Invoice and Expense Processing with AI: OCR, Approval, and Anomaly Detection

Article Summary

Invoice automation is more than converting an image into text. A production workflow must ingest documents, extract fields and line items, match vendors and purchase orders, validate totals and tax, detect duplicates, check budgets and permissions, route human review, obtain approval, post to finance systems, archive evidence, and preserve an audit trail.

This guide designs a practical workflow using Power Automate, AI Builder, or Azure Document Intelligence.

The central rule is:

AI extracts and classifies, deterministic rules validate, business systems own financial state, and humans approve high-risk decisions.

Target Workflow

A company receives 3,000 supplier invoices per month. The current process is email download, manual spreadsheet entry, purchase-order checks, approval, ERP entry, and PDF archiving.

The automated target is:

more than 90% extraction on standard invoices;
confidence stored for every field;
low-confidence cases routed to humans;
automatic duplicate, budget, and PO mismatch detection;
traceable approvals;
only validated records posted to finance systems.

Reference Architecture

Email / SharePoint / Portal / Scanner
→ Power Automate trigger
→ file security and classification
→ AI Builder or Azure Document Intelligence
→ normalization
→ vendor, PO, and receipt matching
→ rules and anomaly signals
→ Power Apps human review
→ approval
→ ERP / finance system
→ archive
→ Power BI monitoring

Microsoft's official reference architecture uses Power Automate for orchestration, AI Builder for extraction, Power Apps for correction, Dataverse for queues and records, and Power BI for analysis: AI document-processing architecture.

Tool Selection

AI Builder and Power Automate

Best when the organization already uses Microsoft 365 and Power Platform and finance teams need a low-code solution.

The prebuilt invoice model extracts invoice ID, supplier, dates, totals, due dates, purchase-order numbers, and other common fields. Simplified Chinese is supported. Custom document models can be trained for additional fields, with Microsoft documentation stating that teams can start with five documents.

Official information: prebuilt invoice model and custom document processing.

Azure Document Intelligence

Best for API integration, large volume, custom applications, structured JSON, and developer-managed infrastructure.

Azure Document Intelligence v4.0 includes prebuilt invoice, layout, and custom models. Official information: overview and invoice model.

OCR plus a language model

A language model can normalize vendor names, map descriptions to expense categories, explain exceptions, and generate approval summaries. It should not independently calculate tax, approve payments, or decide fraud.

Data Model

Store three layers.

Raw

Original file, email ID, uploader, timestamp, hash, OCR text, and model version.

Extracted

Invoice number, invoice date, raw vendor name, tax ID, currency, subtotal, tax, total, PO number, due date, line items, and confidence.

Business

Canonical vendor ID, account code, cost center, project, remaining budget, match status, risk level, approval status, and ERP voucher ID.

Never overwrite raw values. Store normalized values separately with the rule or reviewer responsible for the change.

Power Automate Flow
Trigger from email, SharePoint, Power Apps, Teams, or API.
Validate type, size, page count, encryption, duplicates, malware, and multi-invoice PDFs.
Call AI Builder invoice extraction or a document model.
Normalize names, dates, currency, decimal values, and invoice IDs.
Perform three-way matching across invoice, purchase order, and receipt/service acceptance.
Execute anomaly rules.
Route to review and approval.
Post validated data to ERP.

Microsoft recommends specifying pages when a large file contains only one invoice, reducing prediction cost and improving performance. Official guide: invoice processing in Power Automate.

Deterministic Checks

Examples:

subtotal plus tax does not equal total;
supplier tax ID and invoice number already exist;
duplicate file hash;
future invoice date;
due date earlier than invoice date;
insufficient PO amount;
bank account differs from master data;
submitter is also approver;
budget exceeded;
extraction confidence below threshold.

AI can flag semantic anomalies such as an invoice description that conflicts with the purchase purpose or a note requesting payment to a personal account. These are risk signals, not proof of fraud.

Human Review

A useful review screen shows:

original PDF with highlighted evidence;
extracted fields and confidence;
purchase order and receipt data;
anomaly reasons;
change history;
approve, return, and escalate actions.

Low-risk matched invoices can move directly to approval. Low-confidence or medium-risk invoices require finance review. Duplicate, bank-account-change, or high-risk cases require senior finance or audit review.

Security and Audit

Implement minimum privilege, service-account separation, encryption, retention policies, tamper-resistant logs, masking, model and prompt versioning, reviewer history, deprovisioning, and environment separation.

Do not upload real supplier invoices to personal free AI accounts. Bank accounts, tax IDs, and employee information are sensitive business data.

Pricing

Microsoft's Singapore pricing page currently lists:

Power Automate Premium: USD 15/user/month, paid yearly;
Power Automate Process: USD 150/bot/month, paid yearly;
Hosted Process: USD 215/bot/month, paid yearly.

Prices exclude GST and can vary by contract. Official page: Power Automate pricing.

AI Builder consumes AI credits. Azure Document Intelligence uses pay-as-you-go or commitment pricing rather than a fixed monthly subscription: Azure pricing.

Evaluate total cost per invoice, including licenses, recognition, storage, ERP integration, human review, and maintenance.

Evaluation

Build an anonymous test set of at least 200 documents covering clean PDFs, phone photos, multilingual invoices, multiple currencies, complex line items, low-quality scans, duplicates, and anomalies.

Measure field accuracy, line-item accuracy, straight-through rate, incorrect auto-approval rate, duplicate recall, average review time, failure rate, cycle time, and cost per invoice.

The most important metric is not OCR accuracy. It is the rate at which high-risk errors are incorrectly allowed through.

Four-Week MVP

Week 1

Collect samples, define fields, rules, approval matrix, and ERP interfaces.

Week 2

Build ingestion, extraction, raw/structured storage, and the review interface.

Week 3

Add vendor/PO/receipt matching, duplicate rules, approval routing, retries, and alerts.

Week 4

Pilot with one department and a limited supplier group while running the manual process in parallel.

Final Verdict

AI reads documents, rules validate facts, systems execute the process, and humans remain accountable.

Power Automate plus AI Builder is the fastest low-code route for Microsoft organizations. Azure Document Intelligence is more flexible for API-driven and high-volume systems. Both require human review, deterministic validation, authorization, and auditability.

SEO Information

SEO Title: How to Automate Invoice and Expense Processing with AI
SEO Description: A practical guide to invoice OCR, AI extraction, three-way matching, duplicate detection, approvals, human review, Power Automate, AI Builder, Azure Document Intelligence, pricing, and security.
URL Slug: ai-invoice-expense-automation-ocr-approval-anomaly-detection-guide

For more enterprise AI automation guides, visit Zyentor.

Originally published on Zyentor Picks.

How to Create a Brand Promotional Video with Kling AI: A Complete Commercial Delivery Workflow

cheng zhang — Tue, 14 Jul 2026 03:48:32 +0000

How to Create a Brand Promotional Video with Kling AI: A Complete Commercial Delivery Workflow

Category: AI Video Production / Brand Content

Target readers: brand marketers, agencies, short-video teams, ecommerce operators, freelancers, product managers, and corporate communication teams

Updated: July 14, 2026

Bottom line: Kling AI can now support concept visualization, product atmosphere shots, character motion, camera movement, multi-shot storytelling, and some native audio generation. However, a commercial deliverable should never depend on a single prompt. A reliable workflow is: define the business objective → lock brand assets → write the storyboard → generate shot by shot → review and repair → edit and package → run brand and legal review → export for each channel → archive prompts, rights, and source files.

1. What Brand Videos Is Kling AI Good For?

Kling AI currently provides video, image, sound, and multimodal creation tools. Its official VIDEO 3.0 guide lists text-to-video, image-to-video, start-and-end-frame generation, Multi-Shot, element references, native audio, multilingual support, and flexible 3–15 second output.

Use case	Fit	Notes
Product mood advertisement	Very high	Strong lighting, materials, camera movement, and atmosphere
New-product concept film	Very high	Efficient for validating creative directions
Ecommerce product video	High	Useful for close-ups, rotation, unboxing, and usage scenes
Brand-story sequences	High	Multi-Shot and subject consistency support narrative work
Social advertising	High	Good for vertical variants and rapid testing
Event teaser	High	Produces visually striking shots quickly
Industrial function demo	Medium	Visual appearance is possible; exact mechanics require caution
Regulated claims	Medium-low	Medical, financial, and efficacy claims need legal review
Entire film in one generation	Not recommended	Commercial films should be assembled from controlled shots

In one sentence:

Kling AI works best as a shot-generation engine, not as an automatic replacement for strategy, editing, legal review, and delivery management.

2. Key Kling AI Capabilities in 2026

Based on Kling AI's official website and VIDEO 3.0 guide, the main capabilities include:

Text-to-Video;
Image-to-Video;
Start & End Frames-to-Video;
Multi-Shot cinematic generation;
Element Reference and Subject Binding;
Native Audio;
Chinese, English, Japanese, Korean, and Spanish support;
Flexible 3–15 second output;
Camera movement control;
Integrated image and video workflows.

These improve control, but commercial creators should still expect possible issues:

distorted logos;
incorrect package text;
abnormal hands or movement;
changing product proportions;
inconsistent brand colors;
implausible physics;
unstable pronunciation or lip sync.

Human checkpoints remain mandatory.

3. Commercial Delivery Workflow

Use a 12-stage process:

Stage	Main output
1. Client brief	Goal, audience, channel, product value
2. Delivery scope	Duration, ratios, versions, revisions, rights
3. Creative strategy	Concept, mood, visual direction
4. Script and storyboard	Voiceover, captions, shot list, pacing
5. Brand asset pack	Logo, colors, fonts, product photos, restrictions
6. Keyframes	Approved static visual reference for each shot
7. Kling generation	Text, image, element, and multi-shot generation
8. Selection and regeneration	Pick, repair, replace, and version footage
9. Post-production	Edit, grade, voice, music, captions, graphics
10. Brand and legal review	Trademark, likeness, rights, claims
11. Multi-channel export	TikTok, Reels, YouTube, ecommerce, website
12. Archiving	Sources, prompts, licenses, approvals, deliverables

4. Turn the Client Brief into an Executable Task

Confirm at least the following.

Business objective

awareness;
product launch;
product education;
ecommerce conversion;
channel recruitment;
event promotion;
corporate image.

Audience

age and profession;
region;
pain points;
use context;
purchase drivers;
primary viewing platform.

One core message

A 15–30 second video should normally communicate:

one core benefit;
one scenario;
one call to action.

Channel specifications

Channel	Common ratio	Recommended length
TikTok / Reels / Shorts	9:16	10–30 sec
YouTube	16:9	30 sec or longer
Paid social	9:16, 1:1, 16:9	6–30 sec
Ecommerce page	1:1, 3:4, 16:9	10–60 sec
Digital signage	Custom	Looping

Approval owners

Identify who approves:

the requirement;
the creative direction;
product claims;
brand compliance;
final acceptance.

5. Define AI Project Boundaries in the Quote

The main risk in commercial AI video is often expectation management.

Deliverables example

One 20-second vertical brand promotional video;
1080 × 1920 resolution;
including creative concept, script, storyboard, AI-generated shots,
editing, captions, licensed music, and basic color grading;
one captioned version and one clean version;
two consolidated revision rounds.

AI-generation notice

Parts of this project will be produced with generative AI tools.
AI-generated footage may contain visual randomness.
The final result is based on the approved preview.
For high-precision packaging text, logos, specifications, and product geometry,
real footage, static design, or post-production compositing may be used instead.

Revision scope

Separate:

copy changes;
shot replacement;
style redesign;
product replacement;
additional aspect ratios;
new language versions.

Client warranties

Require the client to confirm rights to:

logos and trademarks;
product images;
people and voices;
music and fonts;
copy and product claims.

6. Write the Script Before the Prompt

A Kling prompt is not a commercial script.

A real storyboard should contain:

Field	Content
Timecode	0–3 sec, 3–7 sec, etc.
Visual	Person, product, environment, action
Camera	Shot size, angle, movement
Voiceover	Spoken copy
On-screen text	Captions and claims
Sound	Music, SFX, ambience
Brand elements	Logo, product, brand color

20-second structure

0–3 sec: hook;
3–10 sec: demonstrate value;
10–16 sec: build brand memory;
16–20 sec: call to action.

7. Build a Brand Asset Pack

Prepare:

transparent PNG logos;
front, side, back, and 45-degree product photos;
RGB, HEX, and CMYK brand colors;
licensed brand fonts;
product dimensions and proportions;
high-resolution package text;
approved visual references;
prohibited competitor styles;
character references;
restricted advertising language.

Consistency sheet

Element	Approved standard	Prohibited outcome
Logo	White horizontal logo	Stretching, recoloring, redrawing
Main colors	Deep blue and gold	Neon saturation
Product	Black bottle and gold cap	Shape changes or label rearrangement
Mood	Premium, restrained, modern	Cartoon or cheap discount style
Talent	Professional adult	Children or exaggerated influencer styling

8. Create Keyframes Before Image-to-Video

For commercial brand work, use:

Brand assets → approved keyframe → image-to-video

rather than relying entirely on text-to-video.

Benefits:

more stable product shape;
easier approval;
better brand-color control;
lower rework cost;
greater continuity across shots.

Keyframes can be created using Kling IMAGE 3.0, Midjourney, OpenAI image generation, Photoshop, Firefly, real product photography, or 3D renders.

Keyframe review

Is the product accurate?
Is the logo correct?
Is packaging text usable?
Is lighting consistent?
Is there space for captions?
Does motion direction make sense?
Can the shot connect to the next one?

Add logos and small packaging text in post whenever accuracy matters.

9. Write Shot-Level Kling Prompts

A controlled commercial prompt should include:

subject + environment + action + camera + lighting + material + brand mood + constraints

Template

[Subject] is in [environment], performing [action].
Use a [shot size] from [camera angle] with [camera movement].
Lighting is [description], with [material quality].
Overall tone: [brand mood] and [color system].
Keep product shape, label placement, primary colors, and proportions consistent.
Avoid distorted text, redrawn logos, extra objects, abnormal hands, and flicker.

Product hero example

A premium deep-blue perfume bottle stands in the center of a black mirrored surface.
Keep the exact reference proportions and gold cap.
A very light mist moves slowly around the bottle.
Use a low-angle camera with a slow push-in, ending on a 45-degree close-up.
Gold rim light defines the edges, with a deep-blue-to-black background.
Premium, restrained, modern luxury advertising style.
Do not add text, change the bottle shape, or create additional products.

Lifestyle example

In a modern apartment at sunrise, a professional woman in her thirties
naturally picks up the reference perfume bottle and sprays it once.
Fine mist is visible in the backlight.
Use a medium close-up with a subtle stabilizer orbit.
Soft morning light, cool blue and warm gold palette, realistic commercial photography.
Keep the face, clothing, and product consistent.
Avoid abnormal fingers, product deformation, and exaggerated acting.

Multi-Shot example

Create a 12-second premium perfume advertisement with three shots:
Shot 1, 3 seconds: wide product view on a black mirrored surface, slow push-in.
Shot 2, 5 seconds: a woman by a window picks up the bottle and sprays once in backlight.
Shot 3, 4 seconds: return to a 45-degree product close-up with stronger gold rim light and a slight camera rise.
Maintain the same product, blue-and-gold brand mood, and continuous lighting logic.
Do not generate brand text or logos; leave them for post-production.

10. Choose the Right Generation Mode

Requirement	Recommended mode
Fully conceptual scene	Text-to-Video
Accurate product appearance	Image-to-Video
Controlled transition	Start & End Frames
Short multi-shot story	Multi-Shot
Consistent person or product	Element Reference / Subject Binding
Specific body movement	Motion Control or video reference
Dialogue or ambient sound	Native Audio

Commercial recommendations:

use image-to-video for products;
use multiple references for talent;
use motion references for complex actions;
add logos and legal text in post;
split videos longer than 15 seconds into shots;
keep exact claims in captions, not generative imagery.

11. Build a Generate–Select–Regenerate Loop

For each important shot:

generate 3–6 candidates;
select the most stable action and composition;
classify the defect;
change one variable at a time;
save prompt and version information.

Problem	Response
Product deformation	Strong reference images and smaller movement
Incorrect logo	Remove generated text and add the logo in post
Face drift	Fixed references, shorter clips, less rapid rotation
Abnormal hands	Reframe, hide hands, substitute motion, or use live footage
Unnatural motion	Split the shot and specify start/end movement
Color drift	Unified keyframes and final color grade
Background artifacts	Simpler environment and stronger constraints
Poor continuity	Start/end frames, consistent references, and edit transitions

File naming

S01_ProductHero_V01.mp4
S01_ProductHero_V02.mp4
S02_Lifestyle_V03_Selected.mp4
S03_EndFrame_V02_ClientApproved.mp4

12. Post-Production Determines Commercial Quality

Recommended tools:

CapCut;
Premiere Pro;
After Effects;
DaVinci Resolve;
Audition;
Photoshop / Illustrator;
professional voice or ElevenLabs where appropriate.

Post-production tasks

Select and reorder shots;
Add exact logos and package text;
Use licensed brand fonts;
Normalize color and grain;
Add music, sound design, and voiceover;
Adjust speed and transitions;
Replace unstable frames with stills or live footage;
Composite and mask defects;
Build the final brand end card;
Adapt all aspect ratios.

Exact information such as logos, product names, prices, efficacy statements, dates, disclaimers, and QR codes should be created in post-production.

13. Sound and Music Workflow

VIDEO 3.0 supports native audio, but brand films should still use layered sound management.

Track	Content
A1	Voiceover
A2	Music
A3	Ambience
A4	Product sound effects
A5	Sonic logo

Native audio is useful for:

ambience;
footsteps, wind, and water;
short dialogue;
synchronized action sounds;
concept previews.

Post-production audio is better for:

final brand narration;
exact product-name pronunciation;
regulated messaging;
multilingual delivery;
licensed music;
reusable sonic branding.

14. Brand and Legal Review

Input rights

Confirm rights to product images, logos, people, architecture, artwork, music, fonts, and third-party references.

People and voices

do not clone people without authorization;
do not present AI characters as real experts or customers;
obtain likeness releases;
obtain explicit voice-cloning consent.

Advertising claims

Review:

absolute claims;
efficacy claims;
health and medical statements;
financial returns;
prices and promotional conditions;
data accuracy;
comparative advertising;
content involving minors.

Kling AI terms

Kling AI's official user policy includes conditions relating to inputs, outputs, platform licenses, and commercial use. It also discusses the platform's license to content and a process for revoking certain authorization.

Do not reduce this to “a paid account automatically grants unlimited commercial rights.” For a serious project:

review the applicable regional agreement on the generation date;
verify the rights provided by the account plan;
save a copy of the terms and payment records;
obtain legal review for high-value campaigns;
avoid uploading unauthorized confidential or personal material;
review data-processing terms for confidential projects.

15. Export and Acceptance

Recommended deliverables

File	Use
9:16 captioned	TikTok, Reels, Shorts
9:16 clean	Future localization
16:9 captioned	YouTube, website, presentations
1:1 square	Paid social
Clean master	Editable archive
Cover image	Publishing thumbnail
SRT subtitles	Localization and reuse

Technical acceptance checklist

correct resolution;
consistent frame rate;
no black or flashing frames;
accurate logo and text;
no clipped audio;
correct captions;
accurate product color;
scannable QR code;
correct safe area;
platform-compliant duration;
clear file names and versions.

16. Practical Case: 20-Second Premium Beverage Video

Goal

Create a 20-second new-product video for a premium non-alcoholic sparkling beverage.

Brand proposition

Light bubbles. A new rhythm for the city at night.

Storyboard

Time	Visual	Generation mode	Post-production
0–3 sec	Cold bottle revealed by rim light	Image-to-Video	Add title
3–7 sec	Cap opens, vapor and bubbles expand	Image-to-Video	Add opening SFX
7–12 sec	Young professionals on a city terrace	Element reference	Add ambience
12–16 sec	Beverage poured into a clear glass	Image-to-Video	Gentle slow motion
16–20 sec	Product hero and brand message	Start/end frames	Logo and CTA

Product shot prompt

The reference premium sparkling beverage bottle stands on a deep-black mirrored table.
Keep the bottle shape, label placement, cap, and liquid color identical to the reference.
Condensation slowly moves down the bottle, with fine bubbles rising inside.
Use a low-angle macro close-up and a slow push-in.
Blue and violet city neon create rim light, with a blurred background.
Premium, refreshing, modern nightlife advertising style.
Do not change the package structure, add text, or create extra bottles.

End card

Headline: Open a new rhythm for the night
Subline: 0% alcohol · fine bubbles · refreshing taste
CTA: Search the brand name and discover the new release

Create the headline and logo in After Effects, Premiere, or CapCut rather than inside the generated footage.

17. Budget and Timeline

AI reduces production cost but does not make production free.

Cost components

strategy and script;
storyboard and keyframes;
Kling subscription and credits;
generation failures and iterations;
editing and motion graphics;
voice and licensed music;
stock or image rights;
communication;
revisions and multi-format delivery;
legal review.

Pricing formula

Project fee = strategy + storyboard + generation + post-production + audio + licensing + revision risk

Example timeline

Stage	Suggested time
Brief and concept	1 day
Script and storyboard	1–2 days
Keyframe approval	1–2 days
AI shot generation	2–4 days
Rough cut	1 day
Client feedback	1 day
Final edit and delivery	1–2 days

18. Project Folder Structure

Brand_Video_Project/
├── 01_Brief/
├── 02_Contract_and_Rights/
├── 03_Script_Storyboard/
├── 04_Brand_Assets/
├── 05_Keyframes/
├── 06_Kling_Generations/
├── 07_Selected_Footage/
├── 08_Edit_Project/
├── 09_Audio/
├── 10_Review_Versions/
├── 11_Final_Deliverables/
└── 12_Prompts_and_Logs/

Archive:

final prompts;
generation dates and model versions;
reference-image sources;
licenses;
approval records;
final delivery checklist.

19. Pre-Delivery Checklist

Is the business objective clear?
Is there only one core message?
Is the product model correct?
Are product colors and proportions accurate?
Is the logo the official file?
Is packaging text correct?
Are people and voices authorized?
Is the music commercially licensed?
Are fonts licensed?
Is voiceover copy factual?
Are performance claims substantiated?
Are prohibited absolute claims removed?
Are face, hand, and physics defects fixed?
Are colors consistent across shots?
Are captions proofread?
Is text readable on a phone?
Are channel safe areas correct?
Is a clean master preserved?
Are prompts and rights records archived?
Has the client approved the final version in writing?

20. Final Verdict

The most effective way to use Kling AI for brand video is not “one prompt, one finished commercial.” It is to embed the model in a professional production pipeline:

Commercial brief → concept → script → storyboard → brand keyframes → shot-level Kling generation → human selection → post-production → brand and legal review → multi-channel delivery.

Kling VIDEO 3.0's Multi-Shot, element reference, native audio, and 3–15 second output make AI footage more controllable. Commercial quality still depends on:

accurate brand assets;
strong shot design;
shot-by-shot version management;
professional post-production;
clear rights and compliance;
structured client approval.

Final recommendation:

Treat Kling AI as a high-efficiency virtual production stage and shot generator, not as a shortcut that removes strategy, design, editing, and legal responsibility.

21. SEO Information

SEO title: How to Create a Brand Promotional Video with Kling AI: Complete Commercial Workflow

SEO description: Learn how to use Kling AI for brand promotional videos, including client briefs, quotes, scripts, storyboards, brand assets, keyframes, Kling VIDEO 3.0 prompts, image-to-video, Multi-Shot, editing, licensing, compliance, and delivery.

Keywords: Kling AI, AI video generator, brand promotional video, AI advertising video, Kling prompt, image to video, commercial AI video, short video workflow, Kling VIDEO 3.0, AI video commercial use

22. Sources

Kling AI official website: Creative Studio, video, image, sound, and VIDEO 3.0 capabilities.

https://kling.ai/
Kling VIDEO 3.0 Model User Guide: text-to-video, image-to-video, start/end frames, native audio, Multi-Shot, element references, multilingual support, and 3–15 second duration.

https://kling.ai/quickstart/klingai-video-3-model-user-guide
All You Need to Know About Kling VIDEO 3.0: unified multimodal generation, Multi-Shot, native audio, subject consistency, and 15-second output.

https://kling.ai/blog/kling-video-3-0-ai-director-features-guide
Kling AI Blog: VIDEO 3.0, Motion Control, native 4K, product-video workflows, and camera control.

https://kling.ai/blog
Kling AI Terms of Use: inputs, outputs, intellectual property, platform licenses, content use, and commercial conditions.

https://kling.ai/docs/user-policy

AI models, prices, credits, commercial terms, and data policies can change. Review the official pages and the agreement applicable to your region and account at the time of contracting and generation.

Publish-ready Summary

Kling AI can support brand promotional videos with product atmosphere shots, image-to-video, character motion, Multi-Shot storytelling, camera movement, and native audio. However, a commercial deliverable should not rely on a single prompt. The correct workflow is to define the business goal and specifications, create a brand asset pack and storyboard, use approved keyframes and image-to-video to protect product consistency, generate and review each shot separately, and complete the work with editing, color grading, exact logos and captions, licensed audio, legal review, and multi-channel exports. Exact logos, packaging text, specifications, and regulated claims should be created and verified in post-production rather than left to a generative model.

Originally published on Zyentor Picks.

How to Use AI to Support English Academic Paper Writing: A Complete Workflow

cheng zhang — Mon, 13 Jul 2026 02:28:35 +0000

Category: Academic Writing / AI Writing Workflow

Target readers: graduate students, PhD students, researchers, non-native English authors, and authors preparing journal or conference submissions

Test date: July 13, 2026

Bottom line: AI can significantly improve the efficiency of English academic writing, especially for outlining, structure, language polishing, abstract revision, reviewer responses, and pre-submission checks. But AI must not fabricate data, invent references, replace author judgment, or be listed as an author. The right division of labor is: humans own the research and claims; AI supports language, structure, and checking.

1. First Principle: AI Is Allowed in Some Ways, But Not All Ways

AI is most useful in three academic writing tasks:

Language support: grammar, expression, academic tone, sentence clarity;
Structural support: abstract structure, introduction logic, transitions, response-letter structure;
Checking support: terminology consistency, figure captions, submission checklists, AI-use disclosure drafts.

AI should not be used to:

fabricate data;
invent references;
create unsupported conclusions;
generate a full paper for direct submission;
replace scholarly contribution;
use large-scale AI-generated text without disclosure;
upload confidential manuscripts or sensitive data to untrusted tools.

Elsevier’s journal policy requires authors to disclose AI tools used for manuscript preparation and document the tool name, purpose, and level of author oversight. Springer Nature also requires researchers to take responsibility for their work and transparently declare AI use in line with its policies. COPE states that AI tools cannot be listed as authors because authorship requires responsibility, consent, and accountability.

One sentence:

AI can be your academic writing assistant, but it cannot be the author of your paper.

2. Recommended Tool Stack

Stage	Tools	Purpose
Topic and structure	ChatGPT / Claude / DeepSeek / Kimi	Research-question refinement, outline, logic check
Literature reading	Elicit / Semantic Scholar / Consensus / NotebookLM	Search, summarize, compare evidence
English polishing	Grammarly / DeepL Write / ChatGPT	Grammar, expression, clarity
Translation support	DeepL / ChatGPT / Kimi	Chinese-English translation, terminology consistency
Citation management	Zotero / Mendeley / EndNote	References and citation styles
Figure/table checking	ChatGPT / Claude	Captions and results description
Submission checks	ChatGPT + manual checklist	Cover letter, highlights, response letter
AI disclosure	ChatGPT + journal policy review	Draft AI-use statement

Recommended base stack:

Zotero + ChatGPT/Claude/DeepSeek + DeepL/Grammarly + human verification

For Chinese authors writing in English:

Chinese research notes → AI-assisted English draft → human fact checking → Grammarly/DeepL language optimization → journal formatting

3. Full Workflow Overview

Academic writing can be divided into 10 steps.

Step	Human responsibility	AI support
Research question	Judge novelty and value	Refine questions and outline options
Literature review	Read originals and evaluate evidence	Summarize and compare papers
Paper outline	Decide logic and contribution	Optimize IMRaD structure
Methods	Report real design	Improve clarity and check missing details
Results	Interpret real data	Convert tables/figures into English description
Discussion	Develop contribution and limitations	Check reasoning and transitions
Abstract/title	Position contribution	Generate versions under constraints
Language polishing	Final author judgment	Grammar, concision, academic tone
Submission package	Confirm journal requirements	Cover letter and highlights draft
Reviewer response	Decide revisions	Polite and structured responses

4. Test Tasks

This guide evaluates AI support across eight academic writing tasks.

Task	What is tested
Research question refinement	Turn a broad topic into publishable questions
Introduction framework	Background, gap, contribution, structure
Methods polishing	Preserve facts while improving English
Results description	Describe tables/figures without inventing results
Discussion logic	Check contribution, interpretation, limitations
Abstract revision	Structured and unstructured abstract versions
Reviewer response	Response to reviewers
AI-use disclosure	Draft disclosure according to journal policy

Scoring criteria

Dimension	Weight	Explanation
Language improvement	20	More natural, accurate, academic English
Structural clarity	15	Better logical organization
Factual fidelity	20	No invented claims or changed meaning
Academic compliance	15	Citations, disclosure, boundaries
Efficiency gain	15	Time saved
Controllability	15	Easy for authors to review and edit

Overall score: 88 / 100

Verdict:

AI’s biggest value in English paper writing is not ghostwriting. It reduces low-value language labor so authors can focus on research logic, evidence, and contribution.

5. Step 1: Refine the Research Question

Do not ask AI to write the paper first. Ask it to help clarify the research question.

Prompt template

I am preparing an academic paper in [field].
My rough topic is: [topic].
Please help me refine it into 3–5 research questions.
For each question, explain:
1. why it may be research-worthy;
2. what data or evidence would be needed;
3. what potential contribution it may make;
4. what risks or limitations it may have.
Do not invent empirical findings.

Human checks

AI-generated research questions are only brainstorming. You must judge:

whether the question is already over-studied;
whether evidence is available;
whether it fits the target journal;
whether it offers theoretical or practical contribution.

6. Step 2: Build the Paper Outline

The most common English research-paper structure is IMRaD:

Introduction
Methods
Results
Discussion

Prompt template

Please create an IMRaD outline for a paper on the following research question:
[research question]

Requirements:
1. Include the purpose of each section;
2. Specify what evidence should be placed in each section;
3. Mark which parts require real data or citations;
4. Do not generate unsupported claims.

Outline checklist

Section	Must answer
Introduction	What is the background, gap, and contribution?
Methods	What are the data, sample, experiment, model, and variables?
Results	What are the findings and supporting figures/tables?
Discussion	Why do findings matter, how do they compare, what are the limitations?
Conclusion	What is the final contribution and implication?

7. Step 3: Write the Introduction

An introduction is not a pile of background information. It builds a logic chain:

Importance → prior work → research gap → research question → method overview → contribution

Diagnostic prompt

Below is my draft introduction. Please evaluate its logic.
Focus on:
1. whether the research gap is clear;
2. whether the contribution is specific;
3. whether each paragraph has a clear function;
4. whether any claim needs citation;
5. whether there are unsupported or overgeneralized statements.
Do not rewrite the whole text yet. First provide a diagnostic report.

Draft:
[paste introduction]

Revision prompt

Please revise the following introduction for clarity, academic tone, and logical flow.
Constraints:
1. Do not add new claims;
2. Do not invent citations;
3. Keep the original meaning;
4. Improve transitions between paragraphs;
5. Mark any sentence that needs a citation with [citation needed].

Text:
[paste text]

8. Step 4: Write the Methods Section

The methods section is about reproducibility, not fancy prose.

AI can help:

improve grammar;
standardize tense;
check missing details;
translate method notes into English;
align subheadings with journal style.

AI must not:

invent sample size;
invent experimental conditions;
invent statistical methods;
invent ethics approval;
decide research design for you.

Prompt template

Please polish the following Methods section.
Rules:
1. Do not change any factual information;
2. Do not add sample size, tools, parameters, or statistical methods;
3. Improve clarity and reproducibility;
4. Use precise academic English;
5. List any missing methodological information at the end.

Text:
[paste methods]

9. Step 5: Write the Results Section

Never let AI freely invent results. Provide real tables, figures, or values.

Prompt template

I will provide a table of results. Please write a Results paragraph.
Rules:
1. Only describe the numbers provided;
2. Do not infer causality unless stated;
3. Highlight the most important patterns;
4. Use cautious academic language;
5. Do not invent p-values, confidence intervals, or effect sizes.

Table:
[paste table]

Useful expressions

Meaning	Academic expression
显著高于	was significantly higher than
呈现上升趋势	showed an increasing trend
差异不明显	the difference was not substantial
与……一致	consistent with
需要谨慎解释	should be interpreted with caution
不能说明因果	does not imply causality

10. Step 6: Write the Discussion Section

The discussion section requires author judgment. AI can support structure but cannot determine contribution.

Recommended structure:

Summarize key findings;
Explain possible mechanisms;
Compare with prior studies;
State theoretical or practical implications;
Explain limitations;
Suggest future research.

Prompt template

Please evaluate the Discussion section below.
Focus on:
1. whether the interpretation is supported by the results;
2. whether the comparison with prior studies is clear;
3. whether the contribution is overstated;
4. whether limitations are specific;
5. whether future research directions are meaningful.
Do not invent references or findings.

Text:
[paste discussion]

11. Step 7: Optimize Abstract and Title

The abstract often determines whether editors and reviewers continue reading.

Abstract prompt

Please rewrite the following abstract in academic English.
Requirements:
1. Keep it within [word limit] words;
2. Include background, objective, methods, results, and conclusion;
3. Do not add findings that are not in the text;
4. Make the contribution clear but not exaggerated;
5. Provide 3 versions: concise, journal-style, and more accessible.

Abstract:
[paste abstract]

Title prompt

Generate 10 academic paper titles based on the abstract below.
Requirements:
1. Avoid exaggerated wording;
2. Keep titles specific and searchable;
3. Include key variables or methods if appropriate;
4. Provide one short title, one descriptive title, and one impact-oriented title.

Abstract:
[paste abstract]

12. Step 8: Polish the English

Good academic English is not about “advanced vocabulary.” It should be:

clear;
accurate;
concise;
logically connected;
terminologically consistent;
not exaggerated.

Conservative editing prompt

Please polish the following academic paragraph.
Use conservative academic editing.
Do not change the meaning.
Do not add new claims.
Keep technical terms unchanged.
Return a revised version and a brief list of changes.

Text:
[paste paragraph]

Clarity prompt

Please improve the clarity and conciseness of the following paragraph.
Do not paraphrase aggressively.
Do not change technical meaning.
Do not remove important details.

Text:
[paste paragraph]

13. Step 9: Write Response to Reviewers

Reviewer responses are ideal for AI assistance because they require polite, structured, accurate writing.

Prompt template

Please help draft a response to the reviewer comment below.
Rules:
1. Be polite and professional;
2. Acknowledge the reviewer’s concern;
3. Explain what changes were made;
4. Refer to the revised manuscript section;
5. Do not overpromise;
6. If disagreeing, disagree respectfully and provide evidence.

Reviewer comment:
[paste comment]

Our actual revision:
[paste what you changed]

Recommended structure

Reviewer Comment:
[comment]

Response:
We thank the reviewer for this helpful comment. ...

Revision made:
We have revised Section X, Paragraph Y, to clarify ...

14. Step 10: AI-Use Disclosure

Policies vary across journals, but the general trend is:

AI cannot be listed as an author;
authors are responsible for all content;
AI-assisted writing often needs disclosure;
confidential manuscripts should not be uploaded to noncompliant tools;
generated images, data, and research claims are especially sensitive.

Disclosure template

During the preparation of this manuscript, the authors used [tool name] to assist with language editing and improving the clarity of selected paragraphs. The authors reviewed and edited all AI-assisted outputs and take full responsibility for the content of the manuscript.

The statement should explain:

which tool was used;
what it was used for;
that the authors reviewed and edited the output;
that the authors take responsibility.

Always check the target journal’s latest policy before submission.

15. Pitfall Checklist

Do not let AI invent references;
Do not let AI create nonexistent data;
Do not submit a fully AI-generated paper;
Do not hide important AI use;
Do not upload unpublished manuscripts to untrusted tools;
Do not let AI determine statistical significance;
Do not let AI define your contribution;
Do not chase fancy words over accuracy;
Do not ignore the target journal’s AI policy;
Do not treat AI output as submission-ready without review.

16. Recommended Workflows

Workflow A: Chinese author writing in English

Chinese research notes → English draft → AI language polishing → human fact check → Grammarly/DeepL review → journal formatting

Workflow B: Existing English draft

English draft → AI logic diagnosis → paragraph-by-paragraph editing → terminology check → abstract/title optimization → submission checklist

Workflow C: Reviewer response

Collect reviewer comments → decide actual revisions → AI drafts response → human checks facts and tone → final submission

Workflow D: Pre-submission check

Journal guidelines → formatting checklist → AI-use disclosure → figure/table captions → citation style → cover letter → final human read

17. Final Verdict

The core principle of AI-assisted academic writing is:

AI can help make your paper clearer, but it cannot make your research truer.

Best uses:

structure refinement;
language improvement;
logic checking;
reviewer-response drafting;
submission-material preparation;
final checklists.

The author must verify all facts, data, references, and conclusions.

Final recommendation:

Treat AI as an English writing editor and research assistant, not as a paper-writing ghostwriter.

18. SEO Information

SEO title: How to Use AI to Support English Academic Paper Writing: A Complete Workflow

SEO description: This guide explains how to use AI to support English academic writing, covering research questions, outlines, introductions, methods, results, discussions, abstracts, polishing, reviewer responses, AI-use disclosure, compliance, and pitfalls.

Keywords: AI academic writing, English paper writing, ChatGPT paper writing, DeepL Write, Grammarly, AI editing, paper abstract, response to reviewers, AI disclosure statement

19. Data Sources and References

Elsevier Generative AI policies for journals: authors should disclose AI tools used for manuscript preparation, including tool name, purpose, and author oversight.

https://www.elsevier.com/about/policies-and-standards/generative-ai-policies-for-journals
Springer Nature AI guidance: researchers must take responsibility and authorship for their work and transparently declare AI use.

https://www.springernature.com/gp/group/ai/ai-guidance-for-our-researchers-and-communities
Nature Portfolio AI editorial policies: AI cannot be an author, and generative AI images/videos are restricted in many publication contexts.

https://www.nature.com/nature-portfolio/editorial-policies/ai
COPE Authorship and AI tools: AI tools cannot be listed as authors because they cannot take responsibility.

https://publicationethics.org/guidance/cope-position/authorship-and-ai-tools
IEEE Author Guidelines for AI-generated text: AI-generated content should be disclosed, identifying the AI system and sections involved.

https://open.ieee.org/author-guidelines-for-artificial-intelligence-ai-generated-text/
Academic journals' AI policies fail to curb the surge in AI-assisted academic writing: research on journal AI policies, disclosure, and real-world AI use.

https://arxiv.org/abs/2512.06705

Publish-ready Summary

AI can significantly improve the efficiency of English academic writing, especially for research-question refinement, outline building, language polishing, abstract/title revision, figure/table description, reviewer responses, and pre-submission checks. But AI must not fabricate data, references, or conclusions, and it cannot replace author judgment. The correct workflow is for authors to own the research facts and scholarly contribution while using AI for language, structure, and checking. Before submission, authors must verify the target journal’s latest AI-use disclosure policy.

Originally published on Zyentor Picks.

How to Build Your Own RAG Knowledge Base Q&A System with DeepSeek

cheng zhang — Sun, 12 Jul 2026 14:10:53 +0000

Category: AI Application Engineering / RAG Knowledge Base Q&A

Target readers: backend developers, AI full-stack developers, enterprise digital teams, product managers, technical leads, and anyone who wants to turn company documents into an AI Q&A assistant

Test date: July 12, 2026

Bottom line: The recommended first version of a DeepSeek-based RAG system is: document parsing → text chunking → embeddings → vector retrieval → DeepSeek answer generation → source citations. Do not start with a complex agent. First build a minimal loop that answers accurately from your documents, refuses unsupported questions, and returns citations.

1. What Problem Does RAG Solve?

RAG means Retrieval-Augmented Generation.

A normal LLM has one obvious limitation:

It does not know your company policies, product manuals, support rules, project files, contract templates, implementation guides, or internal knowledge base.

If you directly ask a model, it may:

hallucinate answers;
return outdated information;
miss internal company knowledge;
fail to cite sources;
guess about policies, prices, contracts, and workflows.

RAG works like this:

User question
→ retrieve relevant materials from your knowledge base
→ provide those materials as context to the model
→ ask the model to answer only from that context
→ return answer + citations

In one sentence:

RAG makes the model answer while looking at your documents, not from vague memory.

2. Why Use DeepSeek for RAG?

DeepSeek API has three practical advantages.

2.1 OpenAI-compatible integration

DeepSeek API documentation says the API is compatible with OpenAI / Anthropic API formats. With the OpenAI SDK, you mainly need to change base_url and api_key.

This is developer-friendly because you can reuse existing code, frameworks, and tooling.

2.2 Good cost profile for Q&A

RAG systems often involve repeated questions and context assembly. Model cost directly affects whether the system can run long term. DeepSeek’s model and pricing page lists the API Base URL as:

https://api.deepseek.com

For knowledge-base Q&A, use cost-efficient models for normal questions and stronger reasoning models for complex cases.

2.3 Long context helps document Q&A

DeepSeek’s V4 Preview announcement says DeepSeek-V4-Pro and DeepSeek-V4-Flash support 1M context length and Thinking / Non-Thinking modes. Long context is useful for manuals, policies, contracts, and long documents.

But remember:

Long context does not eliminate the need for RAG.

You should not put every document into the prompt. It is expensive, slow, hard to cite, and less controllable. Retrieve first, generate second.

3. Standard RAG Architecture

A minimal RAG system usually contains eight modules:

Module	Role	Common tools
Document collection	Upload PDFs, Word, Markdown, web pages, Excel	upload service, crawler, enterprise docs
Document parsing	Convert files into clean text	pdfplumber, unstructured, docx, pandas
Text chunking	Split long documents into chunks	LangChain, LlamaIndex, custom splitter
Embedding	Convert text into vectors	BGE, Jina, Qwen Embedding, OpenAI-compatible services
Vector store	Store and search vectors	FAISS, Milvus, pgvector, Qdrant, Chroma
Retriever	Find relevant chunks for a question	top-k, hybrid search, reranking
Generator	Use DeepSeek to answer from context	DeepSeek Chat Completion API
Citation and evaluation	Return sources, logs, feedback	metadata, logs, evaluation sets

Workflow:

Upload documents
→ parse documents
→ clean text
→ split into chunks
→ embed chunks
→ write into vector store
→ user asks a question
→ embed the question
→ retrieve relevant chunks
→ build RAG prompt
→ DeepSeek generates answer
→ return answer, citations, and confidence notes

4. Recommended Tech Stack for Version 1

Do not start with a complicated microservice system.

Minimal version

Module	Recommendation
Backend	Python + FastAPI
LLM	DeepSeek API
Document format	Markdown / TXT / PDF
Chunking	custom splitter or LangChain TextSplitter
Embedding	BGE / Jina / Qwen Embedding / OpenAI-compatible embedding service
Vector store	Local FAISS
Frontend	Streamlit / React / Next.js
Deployment	Docker + cloud server

Enterprise upgrade

Module	Recommendation
Backend	FastAPI / Node.js / Java Spring Boot
Queue	Redis Queue / Celery
Document storage	MinIO / OSS / S3
Vector store	Milvus / pgvector / Qdrant
Permission	RBAC + department permissions + document permissions
Logs	PostgreSQL + ClickHouse / Loki
Evaluation	golden question set + human feedback + hit-rate metrics
Deployment	Kubernetes / Docker Compose

Do not start with

complex agents;
multi-step tool calling;
automatic policy rewriting;
automatic approval flows;
legal, financial, medical, or contract Q&A without human review;
direct write access to production databases.

Version 1 goal:

When a user asks a question, the system finds evidence and answers from that evidence.

5. Test Tasks and Scoring

Test tasks

Task	Content	Goal
Task 1	Upload 20 product docs	Test parsing and chunking
Task 2	Upload FAQ	Test common Q&A accuracy
Task 3	Upload policy docs	Test clause retrieval and citation
Task 4	Ask cross-document questions	Test multi-chunk synthesis
Task 5	Ask unsupported questions	Test refusal and anti-hallucination
Task 6	Ask procedural questions	Test structured answers
Task 7	Ask mixed Chinese-English terms	Test terminology handling
Task 8	Concurrent Q&A	Test latency and cost

Scoring criteria

Total score: 100.

Dimension	Weight	What it measures
Integration difficulty	10	API and framework integration
Retrieval accuracy	20	Whether the correct chunks are found
Answer reliability	20	Whether answers are grounded and non-hallucinated
Source citation	15	File name, page, section, chunk source
Cost control	15	Model and retrieval cost
Response speed	10	User experience
Scalability	10	Upgrade path to enterprise system

Overall score

Dimension	Score	Notes
Integration difficulty	90/100	OpenAI-compatible and easy to adopt
Retrieval accuracy	84/100	Depends on chunking, embeddings, and reranking
Answer reliability	88/100	Stable with strict prompts
Source citation	86/100	Requires metadata design
Cost control	91/100	Suitable for medium/high-frequency Q&A
Response speed	85/100	Depends on model, top-k, and context size
Scalability	87/100	Can upgrade from FAISS to Milvus/pgvector

Overall score: 87 / 100

Verdict:

DeepSeek is a strong generation layer for RAG, but RAG quality is determined by the whole pipeline: documents, chunking, embeddings, retrieval, reranking, prompts, and evaluation.

6. Project Structure

Suggested structure:

deepseek-rag-demo/
├── app.py                  # FastAPI main app
├── config.py               # configuration
├── requirements.txt        # dependencies
├── .env                    # API key, never commit
├── data/
│   ├── raw/                # raw documents
│   └── processed/          # parsed text
├── vector_store/
│   └── faiss_index/        # FAISS index
├── rag/
│   ├── loader.py           # document loading
│   ├── splitter.py         # text chunking
│   ├── embeddings.py       # embedding calls
│   ├── retriever.py        # retrieval logic
│   ├── prompt.py           # prompt templates
│   └── generator.py        # DeepSeek generation
└── tests/
    └── eval_questions.json # test questions

7. Install Dependencies

requirements.txt example:

fastapi==0.115.0
uvicorn==0.30.6
python-dotenv==1.0.1
openai==1.99.0
faiss-cpu==1.8.0
sentence-transformers==3.0.1
pydantic==2.8.2
numpy==1.26.4
pypdf==4.3.1
python-multipart==0.0.9

Install:

pip install -r requirements.txt

.env:

DEEPSEEK_API_KEY=your_deepseek_api_key
DEEPSEEK_BASE_URL=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-v4-flash

If model names change, follow DeepSeek’s official model and pricing page.

8. Call DeepSeek API

Because DeepSeek is OpenAI-compatible, you can call it with the OpenAI SDK:

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

def ask_deepseek(messages, model="deepseek-v4-flash"):
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.2,
    )
    return response.choices[0].message.content

RAG recommendations:

Parameter	Advice
`temperature`	0–0.3 to reduce hallucination
`top_p`	default unless randomness needs reduction
`max_tokens`	limit by answer length
thinking mode	use for complex reasoning, not every FAQ
model choice	cheap model for normal Q&A, strong model for complex questions

9. Parse Documents

Start with TXT / Markdown / PDF.

from pathlib import Path
from pypdf import PdfReader


def load_txt(path: str) -> str:
    return Path(path).read_text(encoding="utf-8")


def load_pdf(path: str) -> str:
    reader = PdfReader(path)
    pages = []
    for i, page in enumerate(reader.pages):
        text = page.extract_text() or ""
        pages.append(f"\n[PAGE {i + 1}]\n{text}")
    return "\n".join(pages)


def load_document(path: str) -> str:
    if path.endswith(".pdf"):
        return load_pdf(path)
    if path.endswith(".txt") or path.endswith(".md"):
        return load_txt(path)
    raise ValueError("Unsupported file type")

Enterprise parsing is harder:

scanned PDFs need OCR;
tables need structure preservation;
Word files need heading hierarchy;
Excel needs Sheet/row/column handling;
web pages need navigation and footer cleanup;
policy docs need section numbers.

10. Text Chunking Strategy

Chunking is critical.

If chunks are too large:

retrieval is less precise;
context cost is high;
answers contain irrelevant material.

If chunks are too small:

semantics are incomplete;
clause context is lost;
the model needs too many chunks.

Recommended chunk settings

Document type	Chunk size	Overlap
FAQ	one Q&A per chunk	0
Product docs	500–800 Chinese characters	80–150
Policy clauses	by chapter/clause	keep parent title
Course notes	800–1200 Chinese characters	150–200
API docs	by endpoint/method	keep parameter docs

Simple splitter:

def split_text(text: str, chunk_size=800, overlap=120):
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks

Better method:

split by heading hierarchy
→ then by paragraphs
→ then by length fallback

Store metadata for every chunk:

{
  "source": "support_policy.pdf",
  "page": 3,
  "section": "2.3 Return rules",
  "chunk_id": "policy_003_002"
}

11. Embeddings and Vector Store

Embedding converts text into vectors. A vector store finds similar vectors.

LlamaIndex explains that RAG converts data and queries into embeddings, then a vector store finds data numerically similar to the query embedding. FAISS documentation describes Faiss as a library for efficient similarity search and clustering of dense vectors.

For version 1, use a local embedding model + FAISS:

from sentence_transformers import SentenceTransformer
import numpy as np
import faiss

embed_model = SentenceTransformer("BAAI/bge-small-zh-v1.5")


def embed_texts(texts):
    vectors = embed_model.encode(texts, normalize_embeddings=True)
    return np.array(vectors).astype("float32")


def build_faiss_index(chunks):
    vectors = embed_texts(chunks)
    dim = vectors.shape[1]
    index = faiss.IndexFlatIP(dim)
    index.add(vectors)
    return index, vectors

Search:

def search(query, index, chunks, metadatas, top_k=5):
    q_vec = embed_texts([query])
    scores, ids = index.search(q_vec, top_k)
    results = []
    for score, idx in zip(scores[0], ids[0]):
        results.append({
            "score": float(score),
            "text": chunks[idx],
            "metadata": metadatas[idx]
        })
    return results

Vector store choices

Stage	Recommended
Local demo	FAISS
Single-machine product	Chroma / Qdrant
Enterprise system	Milvus / pgvector / Qdrant
Strong relational permissions	PostgreSQL + pgvector
Large-scale retrieval	Milvus / Qdrant

12. Build the RAG Prompt

The prompt must constrain the model:

answer only from context;
say unknown when unsupported;
cite sources;
do not invent policies, prices, contracts, or workflows;
separate evidence from inference.

Template:

RAG_SYSTEM_PROMPT = """
You are an enterprise knowledge-base Q&A assistant.
You must answer strictly based on the provided [Reference Materials].

Rules:
1. If the answer is not in the reference materials, say: "The current knowledge base does not contain a clear answer."
2. Do not invent policies, prices, workflows, contract terms, contacts, or commitments.
3. Give the conclusion first, then the evidence.
4. If sources conflict, point out the conflict instead of deciding by yourself.
5. Cite each key conclusion with source markers such as [Source 1].
"""


def build_rag_messages(question, retrieved_docs):
    context_parts = []
    for i, doc in enumerate(retrieved_docs, start=1):
        meta = doc["metadata"]
        context_parts.append(
            f"[Source {i}] File: {meta.get('source')}, Page: {meta.get('page')}, Section: {meta.get('section')}\n{doc['text']}"
        )

    context = "\n\n".join(context_parts)

    user_prompt = f"""
[Reference Materials]
{context}

[User Question]
{question}

Please answer based on the reference materials.
"""

    return [
        {"role": "system", "content": RAG_SYSTEM_PROMPT},
        {"role": "user", "content": user_prompt}
    ]

13. Full Q&A Chain

def rag_answer(question, index, chunks, metadatas):
    retrieved = search(
        query=question,
        index=index,
        chunks=chunks,
        metadatas=metadatas,
        top_k=5
    )

    messages = build_rag_messages(question, retrieved)
    answer = ask_deepseek(messages)

    sources = [doc["metadata"] for doc in retrieved]

    return {
        "answer": answer,
        "sources": sources,
        "retrieved": retrieved
    }

Example response:

{
  "answer": "According to the knowledge base, the standard support response time is within 24 hours. [Source 1] Hardware repair requires an SN code and fault photos first. [Source 2]",
  "sources": [
    {"source": "support_policy.pdf", "page": 3, "section": "2.1 Response time"},
    {"source": "hardware_repair.md", "page": 1, "section": "Required materials"}
  ]
}

14. FastAPI Endpoint Example

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="DeepSeek RAG Knowledge Base")

class AskRequest(BaseModel):
    question: str

@app.post("/ask")
def ask(req: AskRequest):
    result = rag_answer(
        question=req.question,
        index=GLOBAL_INDEX,
        chunks=GLOBAL_CHUNKS,
        metadatas=GLOBAL_METADATAS
    )
    return result

Run:

uvicorn app:app --host 0.0.0.0 --port 8000

Request:

curl -X POST http://localhost:8000/ask \
  -H "Content-Type: application/json" \
  -d '{"question":"What is the support response time?"}'

15. Frontend Suggestions

Version 1 needs four areas:

Area	Function
Left document panel	upload, delete, update documents
Center chat window	user question and AI answer
Right citation panel	matched documents, pages, chunks
Bottom feedback bar	useful / not useful / wrong answer

Enterprise version also needs:

login;
department permissions;
document permissions;
Q&A logs;
sensitive-word filtering;
human handoff;
question review;
knowledge update reminders.

16. How to Reduce Hallucination

The main issue is not whether the system can answer. It is whether it refuses when it should.

16.1 Prompt constraint

Use:

If the answer is not in the materials, say: "The current knowledge base does not contain a clear answer."

16.2 Retrieval score threshold

If the best similarity score is too low, do not force an answer.

if retrieved[0]["score"] < 0.35:
    return {
        "answer": "The current knowledge base does not contain a clear answer. Please contact human support.",
        "sources": []
    }

16.3 Require citations

Every key conclusion must cite a source.

16.4 Use low temperature

RAG Q&A usually does not need creativity.

temperature=0.2

16.5 Block high-risk overreach

For contracts, prices, legal, financial, HR, and medical questions, add human fallback.

17. How to Improve Retrieval Accuracy

17.1 Optimize chunking

Split semantically, not just by character count.

17.2 Keep heading hierarchy

Example:

Product Manual > Account Management > Password Reset > Forgot Password

17.3 Add metadata

Use:

file name;
page;
section;
document type;
effective date;
department;
permission level.

17.4 Use hybrid retrieval

Vector search handles semantic similarity. Keyword search handles exact terms.

Enterprise recommendation:

vector search + BM25 keyword search + reranking

17.5 Build an evaluation set

Prepare 100–300 real questions:

Field	Example
question	How many days do customers have to request a return?
expected_source	support_policy.pdf page 3
expected_answer	within 7 days
category	support

Run evaluation after every major update.

18. Cost Optimization

18.1 Embed documents only once

If documents do not change, do not re-embed them.

18.2 Cache frequent questions

Many FAQ questions repeat.

user question → normalize → check cache → run RAG only if cache misses

18.3 Control top-k

More retrieved chunks are not always better.

Scenario	Suggested top-k
FAQ	3
Product docs	5
Policy Q&A	5–8
Cross-document synthesis	8–12

18.4 Model routing

Question type	Strategy
Simple FAQ	fast low-cost model
Complex policy interpretation	stronger model / thinking mode
unsupported question	rules + retrieval threshold
summary	mid-tier model

18.5 Limit context length

Only provide truly relevant chunks to the model.

19. Enterprise Considerations

19.1 Permissions

Different departments may access different documents.

Examples:

presales sees product materials;
support sees troubleshooting docs;
finance sees pricing policy;
normal employees cannot see contract templates.

Filter by permissions before retrieval.

19.2 Document versions

Old documents can pollute answers.

Add metadata:

{
  "version": "2026.07",
  "effective_date": "2026-07-01",
  "status": "active"
}

19.3 Logs and audit

Log:

user question;
retrieved documents;
model answer;
model used;
token cost;
user feedback.

19.4 Human fallback

For low-confidence questions:

The current knowledge base does not contain a clear answer. Please contact human support.

19.5 Sensitive information

Do not send these directly to external APIs:

ID numbers;
phone numbers;
full contracts;
customer privacy data;
internal credentials;
raw sensitive data.

20. Upgrade Path from Demo to Production

Stage 1: Local demo

TXT / PDF → FAISS → DeepSeek → simple Q&A page

Goal: validate the RAG loop.

Stage 2: Department knowledge base

document management → permissions → vector store → citations → feedback

Goal: let one department use it.

Stage 3: Enterprise knowledge base

multi-department permissions → document versions → hybrid retrieval → evaluation set → audit logs

Goal: stable internal Q&A.

Stage 4: Business agent

RAG Q&A → tool calling → ticket system → CRM → ERP → human fallback

Goal: move from answering questions to handling business tasks.

21. Common Mistakes

Mistake 1: Calling DeepSeek without retrieval

That is a chatbot, not RAG.

Mistake 2: Putting full documents into the prompt

It is expensive, slow, and hard to cite.

Mistake 3: Random chunking

Chunking determines much of RAG quality.

Mistake 4: No citations

Enterprise users need evidence, not just answers.

Mistake 5: No refusal mechanism

The system should say unknown when it does not know.

Mistake 6: No evaluation set

Without evaluation, you cannot tell whether updates improve or break the system.

Mistake 7: Ignoring permissions

Unauthorized answers create major risk.

22. Final Verdict

Building a RAG knowledge-base Q&A system with DeepSeek is not just calling a model API. The real system is a reliable pipeline:

documents → chunks → embeddings → retrieval → generation → citations → feedback → evaluation

DeepSeek is suitable as the generation layer, especially for cost-sensitive Chinese Q&A, long-document Q&A, and enterprise knowledge-base scenarios.

But final quality depends on the whole engineering pipeline:

clean documents;
reasonable chunking;
matching embeddings;
accurate retrieval;
strict prompt constraints;
clear citations;
evaluation and feedback.

Final recommendation:

Do not start with a complex agent. First build a minimal RAG system with DeepSeek + FAISS + FastAPI that answers accurately from documents, returns citations, and refuses unsupported questions. Then upgrade to Milvus/pgvector, hybrid retrieval, permissions, logs, evaluation, and business-system integration.

23. SEO Information

SEO title: How to Build Your Own RAG Knowledge Base Q&A System with DeepSeek

SEO description: This guide explains how to build a DeepSeek-based RAG knowledge-base Q&A system, covering RAG architecture, document parsing, chunking, embeddings, FAISS vector search, DeepSeek API calls, prompt templates, FastAPI, hallucination control, cost optimization, permissions, and enterprise deployment.

Keywords: DeepSeek, DeepSeek API, RAG, knowledge base Q&A, vector database, FAISS, Embedding, FastAPI, LangChain, LlamaIndex, enterprise knowledge base, AI Q&A system, retrieval augmented generation

24. Data Sources and References

DeepSeek API Docs: DeepSeek API is compatible with OpenAI / Anthropic API formats and can be used through SDK configuration changes.

https://api-docs.deepseek.com/
DeepSeek Models & Pricing: DeepSeek API Base URL, models, pricing, and Thinking / Non-Thinking mode information.

https://api-docs.deepseek.com/quick_start/pricing
DeepSeek Create Chat Completion: Chat Completion API, thinking, reasoning_effort, max_tokens, and related parameters.

https://api-docs.deepseek.com/api/create-chat-completion
DeepSeek V4 Preview Release: DeepSeek-V4-Pro / V4-Flash, 1M context length, and Thinking / Non-Thinking modes.

https://api-docs.deepseek.com/news/news260424
LlamaIndex RAG Introduction: embeddings, vector stores, and retrieval basics in RAG.

https://developers.llamaindex.ai/python/framework/understanding/rag/
LlamaIndex Vector Stores: vector stores contain embeddings of ingested document chunks and can be persisted.

https://developers.llamaindex.ai/python/framework/module_guides/storing/vector_stores/
FAISS documentation: Faiss is a library for efficient similarity search and clustering of dense vectors.

https://faiss.ai/index.html
LangChain GitHub: LangChain is a framework for building agents and LLM-powered applications.

https://github.com/langchain-ai/langchain

Publish-ready Summary

This guide explains how to build a DeepSeek-based RAG knowledge-base Q&A system. It starts with the principle of RAG and explains why enterprise document questions should not be answered by the model alone. The article walks through document parsing, text chunking, embeddings, vector search, RAG prompt construction, DeepSeek API calls, FastAPI endpoints, citations, hallucination control, retrieval optimization, cost reduction, permissions, logging, and the upgrade path from local demo to enterprise deployment. The final recommendation is to first build a minimal RAG system with DeepSeek + FAISS + FastAPI, then upgrade to hybrid retrieval, reranking, permissions, evaluation, and business-system integration.

Originally published on Zyentor Picks.

How to Use ElevenLabs to Create Professional AI Voiceovers for Your Videos

cheng zhang — Fri, 10 Jul 2026 04:11:56 +0000

Category: AI Tool Tutorial / AI Voiceover

Target readers: short-video creators, knowledge creators, course creators, product managers, global content teams, ad editors, and social media operators

Test date: July 10, 2026

Bottom line: ElevenLabs can turn a normal video script into a professional-sounding AI voiceover, but great AI narration is not just “paste text and generate.” The right workflow is script rewriting, voice selection, pacing control, segmented generation, human review, mixing, subtitle syncing, and compliance checking.

1. What Videos Is ElevenLabs Good For?

ElevenLabs is strongest at natural, stable, commercial-quality AI speech. Its official documentation describes Text to Speech, Voice Cloning, Dubbing, Voiceover Studio, APIs, SDKs, and conversational voice agents, making it a broader AI voice infrastructure platform.

It works especially well for:

Video type	Fit	Notes
Educational short videos	High	Clear, stable narration
Product explainers	High	Commercial and brand-friendly voiceover
Software tutorials	High	Step-by-step instruction
Course videos	High	Scalable chapter narration
YouTube / TikTok / Xiaohongshu videos	High	Batch multilingual content
Ad demos	High	Quickly test different voices
Audiobooks / long articles	Medium-high	Better for nonfiction
Film-style acting	Medium	Humans are still better for complex performance
Celebrity-like voice replication	Not recommended	Requires authorization; do not impersonate

In one sentence:

ElevenLabs is best for professional narration and content production, not impersonation or unauthorized voice copying.

2. Full Workflow Overview

Use this eight-step workflow for professional AI voiceovers:

Step	Goal	Tool
1. Define video type	Decide voice style	ChatGPT / notes
2. Rewrite script	Make text speakable	ChatGPT / manual editing
3. Choose voice	Match brand and audience	ElevenLabs Voice Library
4. Generate in segments	Control rhythm and reduce errors	ElevenLabs TTS / Voiceover Studio
5. Human review	Check tone, pronunciation, pauses	Ears + script
6. Mix audio	BGM, volume, noise, loudness	CapCut / Premiere / Audition
7. Sync subtitles	Improve watch-through and clarity	CapCut / Premiere
8. Compliance check	Avoid cloning and commercial risks	Consent / terms / labeling

3. Step 1: Define the Voice Style

Do not open ElevenLabs first. Answer five questions:

Who is watching the video?
Is the tone serious, casual, commercial, educational, or emotional?
Should the voice sound male, female, or neutral?
Should the pace be fast or slow?
Is the video in Chinese, English, or mixed language?

Style guide

Video type	Voice recommendation	Tone
Educational video	Clear neutral voice	Stable, credible, light
Product ad	Mature commercial voice	Confident and concise
Software tutorial	Warm explanatory voice	Slower and clear
Business analysis	Deeper steady voice	Professional and restrained
Lifestyle video	Friendly natural voice	Relaxed and conversational
English global content	Natural US/UK voice	Clear and international
Course video	Durable voice	Stable and not exaggerated

Voice brief template

Video type: AI tool tutorial
Audience: ordinary professionals
Voice style: clear, professional, slightly upbeat, not too announcer-like
Pace: medium-fast
Language: mainly Chinese, keeping terms like ChatGPT, Midjourney, and API
Goal: help viewers understand the tool in three minutes

4. Step 2: Rewrite Written Copy into Spoken Script

Even the best voice model will sound fake if the input is written like a report.

Bad example

This tool improves user experience by integrating multimodal capabilities and intelligent workflows to reduce manual operation costs.

Better spoken version

The biggest value of this tool is simple:
it helps you avoid repetitive work.

For example, writing scripts, making covers, and organizing materials
used to take one or two hours.

Now, with AI, you can get a first draft in minutes.

Spoken-script rules

Rule	Why
Use short sentences	Easier to sound natural
Add pauses	Commas, periods, and line breaks guide rhythm
Avoid jargon	Words like “empower” and “closed loop” sound artificial
Use examples	Real examples make narration human
Start with the point	Short-video viewers have little patience
Read it aloud	If you cannot read it smoothly, AI will not either

Prompt: rewrite copy for narration

Rewrite the following copy into a video voiceover script for ElevenLabs.

Requirements:
1. Conversational but not too casual;
2. Short sentences;
3. Use line breaks for pauses;
4. Keep key terms;
5. Fit a 60-second short video;
6. Avoid exaggerated marketing tone;
7. Output the final narration script.

Original copy:
[paste copy]

5. Step 3: Choose the Right Voice

ElevenLabs provides a large Voice Library. Its documentation says users can choose voices, design voices, or clone voices, with 10,000+ voices available.

Do not choose a voice only because it sounds nice. Choose it because it fits the video.

Voice selection checklist

Dimension	Question
Gender and age impression	Does it fit the audience?
Pace	Does it fit the video speed?
Timbre	Warm, bright, deep, mature, or energetic?
Credibility	Does it sound like a real expert or brand narrator?
Emotion	Too flat or too dramatic?
Language fit	Does it handle Chinese, English, or mixed terms?
Listening endurance	Can people listen for five minutes without fatigue?

Recommendations

Scenario	Voice type
AI tool tutorial	Clear, young, professional neutral voice
Product promo	Mature commercial brand voice
Course narration	Stable, warm, easy-to-listen voice
Short-video narration	Light, energetic, slightly emotional voice
Corporate video	Calm, credible, formal voice
English ad	Natural US/UK commercial voice

Avoid

overly theatrical voices;
robotic assistant voices;
cloning other people without permission;
celebrity-like voices for commercial content;
sacrificing clarity for uniqueness.

6. Step 4: Generate Voiceover in ElevenLabs

ElevenLabs Text to Speech converts text into lifelike audio with intonation, pacing, and emotional awareness. For video creators, there are two common approaches.

Method A: Text to Speech

Best for:

short videos;
product explainers;
1–3 minute videos;
single-speaker narration;
fast audio generation.

Workflow:

Choose voice;
Paste spoken script;
Adjust model and settings;
Generate audio;
Download MP3 or WAV;
Import into editing software.

Method B: Voiceover Studio

ElevenLabs Voiceover Studio documentation shows users can create voiceover projects from the Audio Tools section of the Dashboard. It is better for more complex voiceover projects.

Best for:

multi-segment narration;
longer videos;
courses;
multi-speaker content;
ad storyboard voiceover;
projects that need later edits.

7. Step 5: Generate in Segments

A common beginner mistake is pasting a five-minute script and generating it all at once.

Problems:

mistakes are hard to fix;
tone becomes flat;
pauses are harder to control;
one bad section may require full regeneration;
editing becomes messy.

Segmentation guide

Video length	Recommended segmentation
30 seconds	1–2 segments
60 seconds	3–5 segments
3 minutes	8–12 segments
10-minute course	Generate by lesson sections
30-minute long content	Generate by chapter and subsection

Example structure

Segment 1: opening hook
Segment 2: pain point
Segment 3: tool introduction
Segment 4: demo steps
Segment 5: summary and call to action

This makes editing much easier.

8. Step 6: Control Tone, Pauses, and Emphasis

Script formatting strongly affects ElevenLabs output.

Use line breaks for pauses

Today, we are not going to explain complicated theory.

We will focus on one thing:

how ordinary people can create professional AI voiceovers.

Use short sentences

Write the script first.
Choose the voice.
Then mix audio and add subtitles.

Use punctuation

Punctuation	Effect
Comma	light pause
Period	stronger pause
Colon	emphasis
Dash	delayed turn
Line break	structural pause

Add delivery notes

Tone: natural, professional, slightly excited, but not exaggerated.
Pace: medium.
Emotion: like a knowledgeable friend explaining a useful tool.

Avoid too many exclamation marks

Too many exclamation marks can make the voice sound fake.

9. Step 7: Always Review the Audio

Do not publish AI voiceover immediately after generation.

Check these eight items:

Check	What to look for
Pronunciation	Technical terms and mixed languages
Pauses	Strange mid-sentence breaks
Emotion	Too excited, too flat, or too ad-like
Pace	Does it match the visuals?
Volume	Are segments consistent?
AI feel	Too smooth or lacking human breath
Subtitle match	Does the text match the audio?
Compliance	Is it impersonating or misleading?

Review tips

Listen with headphones;
Listen again through phone speakers;
Listen with visuals in the editing timeline;
Regenerate only unnatural segments;
Do not keep obvious errors just to save credits.

10. Step 8: Mix in Your Editing Software

Professional narration is not just the voice. It also depends on mixing.

Recommended tools

Tool	Best for
CapCut / Jianying	Short-video creators
Premiere Pro	Professional editing
DaVinci Resolve	Video editing and color
Audition	Audio refinement
Final Cut Pro	Mac creators
Canva	Lightweight social videos

Basic mixing settings

Item	Recommendation
Voice volume	Clear, no clipping
BGM volume	Much lower than voice
First second	Add slight fade-in
Ending	Add fade-out
Noise reduction	Usually light only
Loudness	Keep segments consistent
EQ	Slightly improve speech clarity

Simple rule

Voice comes first. Music only supports the mood.

If viewers cannot hear the narration clearly, the mix fails.

11. Step 9: Sync Subtitles

Subtitles are almost mandatory for short videos.

Benefits:

higher completion rate;
watchable without sound;
stronger key-message delivery;
easier understanding;
better multi-platform distribution.

Subtitle workflow

Generate the voiceover first;
Import into CapCut or Premiere;
Auto-generate subtitles;
Manually correct errors;
Adjust line breaks;
Highlight keywords;
Export with subtitles.

Subtitle tips

Keep lines short;
Use 1–2 lines per screen;
Highlight keywords;
Fix technical terms manually;
Standardize mixed Chinese-English terms;
Do not cover the main subject.

12. Step 10: Be Careful with Voice Cloning

ElevenLabs voice cloning is powerful, but it is also high-risk.

ElevenLabs safety documentation says the platform blocks cloning of celebrity and high-risk voices and requires technical verification for Professional Voice Cloning. Pricing shows Instant Voice Cloning starts from Starter, while Professional Voice Cloning starts from Creator.

Acceptable uses

cloning your own voice;
cloning a fully authorized brand narrator;
updating course content with your own voice;
keeping the same voice across multilingual videos;
podcast repair lines.

Do not use it for

cloning friends, bosses, or clients;
cloning celebrities;
impersonation;
scams, deception, or controversy;
unauthorized commercial ads;
making viewers believe a real person said something they did not say.

Labeling suggestion

For commercial or sensitive content, consider adding:

This video uses AI-generated voiceover and has been manually reviewed.

13. Pricing Recommendations

According to ElevenLabs pricing:

Plan	Price	Best for
Free	$0	Testing TTS, STT, voice design, and Studio projects
Starter	$6	Individual creators; commercial license and Instant Voice Cloning
Creator	$22, first month $11	Higher-volume creators and Professional Voice Cloning
Pro	$99	Professional content teams
Scale	$299	Batch production and team collaboration
Business	$990	Enterprise content teams
Enterprise	Custom	SSO, SLA, and compliance requirements

API pricing lists TTS Multilingual v2/v3 at $0.10 per 1,000 characters and Flash/Turbo at $0.05 per 1,000 characters. For ordinary video voiceover creators, start with the web app before using the API.

Plan guide

Usage	Recommended plan
Occasional testing	Free
A few short videos per week	Starter
Frequent videos, courses, audio content	Creator
Team production	Pro / Scale
AI voice product	API / Enterprise

14. Practical Example: 60-Second AI Tool Video Voiceover

Topic

Introduce how to use AI tools to quickly draft a public-account article.

Spoken script

If every article starts from a blank document,
you are moving too slowly.

A better workflow is simple:

first, let AI build the structure.
Then, let it create the first draft.
Finally, you revise the opinions and examples.

This is not about letting AI replace your writing.

It is about letting AI handle the most time-consuming first step.

For example, you can enter a title:
“How to use AI for content operations?”

Then ask AI for an outline, examples, SEO keywords, and an opening paragraph.

After that, you add your own experience
and make the article more real.

In this way, an article can go from idea to first draft
in just a few minutes.

ElevenLabs settings

Item	Recommendation
Voice	Clear, professional, young Chinese voice
Pace	Medium
Emotion	Slightly positive, not salesy
Segments	4–5 segments
Export	WAV preferred, MP3 acceptable
Post-production	Lower BGM volume and highlight subtitles

15. FAQ

15.1 Why does my voiceover still sound like AI?

Common reasons:

script is too written;
sentences are too long;
no punctuation;
wrong voice;
emotion setting is too strong;
generated as one long piece;
no mixing.

15.2 Is Chinese voiceover natural?

It is already strong for educational, tutorial, and commercial narration. Mixed Chinese-English terms, casual particles, dialects, and strong emotions still need manual review.

15.3 Can I use it commercially?

It depends on your plan, voice license, platform rules, and content use. Starter and above are usually more practical for commercial creators, but you should still check official terms and voice permissions.

15.4 Can I clone another person’s voice?

Do not do this without explicit authorization, especially for commercial use.

15.5 Should I say the narration is AI-generated?

For ordinary tutorials, it may not always need large on-screen labeling. For commercial, sensitive, news, personality, or potentially misleading content, clear disclosure is safer.

16. Recommended Workflows

Short-video creator

ChatGPT script → manual spoken rewrite → ElevenLabs voiceover → CapCut subtitles and BGM → publish

Course creator

Course outline → chapter scripts → segmented ElevenLabs generation → review → normalize volume → upload

Product promo

Selling points → narration script → commercial voice → generate versions → team review → Premiere mix → export

Global content team

Chinese script → international rewrite → translation → ElevenLabs multilingual voiceover → subtitle sync → native-speaker review

17. Pitfall Checklist

Do not paste written copy directly;
Do not generate the entire script at once;
Do not choose a mismatched voice;
Do not let BGM cover the voice;
Do not skip subtitle proofreading;
Do not clone unauthorized voices;
Do not use AI voice to impersonate a real person;
Do not skip human review;
Do not treat AI voice as proof of identity;
For commercial videos, check licenses, terms, and platform rules.

18. Final Verdict

Using ElevenLabs for professional video AI voiceover is not about clicking generate once. It requires a complete workflow:

spoken script → voice selection → segmented generation → human review → mixing → subtitles → compliance check.

ElevenLabs helps ordinary creators get close to studio-quality narration quickly, greatly reducing production cost for short videos, courses, ads, and multilingual content.

But it does not replace all human voiceover work, and it should never be used to impersonate people.

Final recommendation:

Treat ElevenLabs as a professional AI voice studio that improves video production efficiency, not as a voice copier for identity confusion.

19. SEO Information

SEO title: How to Use ElevenLabs to Create Professional AI Voiceovers for Your Videos

SEO description: This guide explains how to use ElevenLabs for video AI voiceovers, covering script rewriting, voice selection, Text to Speech, Voiceover Studio, segmented generation, review, CapCut/Premiere mixing, subtitles, voice cloning compliance, pricing, and practical examples.

Keywords: ElevenLabs, AI voiceover, AI narration, video voiceover, AI voice synthesis, Text to Speech, TTS, AI short-video voiceover, AI course narration, AI voice cloning, ElevenLabs tutorial

20. Data Sources and References

ElevenLabs Documentation: Text to Speech, Speech to Text, Voice Cloning, Conversational Agents, API, SDK, and Studio capabilities.

https://elevenlabs.io/docs/overview/intro
ElevenLabs Text to Speech docs: TTS API turns text into lifelike audio with intonation, pacing, and emotional awareness.

https://elevenlabs.io/docs/overview/capabilities/text-to-speech
ElevenLabs Voiceover Studio docs: create voiceover projects from Dashboard Audio Tools.

https://elevenlabs.io/docs/eleven-creative/audio-tools/voiceover-studio
ElevenLabs Dubbing docs: translates audio and video across languages while preserving emotion, timing, tone, and speaker characteristics.

https://elevenlabs.io/docs/overview/capabilities/dubbing
ElevenLabs Models docs: eleven_v3, eleven_flash_v2_5, Multilingual v2, Scribe, and other models.

https://elevenlabs.io/docs/overview/models
ElevenLabs Pricing: Free, Starter, Creator, Pro, Scale, Business, Enterprise plans and credits.

https://elevenlabs.io/pricing
ElevenLabs API Pricing: TTS, STT, Speech Engine, Voice Changer, Voice Isolator, and Dubbing pricing.

https://elevenlabs.io/pricing/api
ElevenLabs Safety: cloning restrictions, Professional Voice Cloning verification, and AI Speech Classifier.

https://elevenlabs.io/safety
ElevenLabs SynthID blog: SynthID watermarking started for free-user TTS and is planned to expand across audio generations.

https://elevenlabs.io/blog/synthid

Publish-ready Summary

This article is a practical guide to using ElevenLabs for professional AI video voiceovers. It explains the full workflow from script rewriting, voice selection, TTS generation, segmentation, human review, audio mixing, subtitle syncing, and compliance checking. It emphasizes that ElevenLabs is suitable for short videos, product explainers, courses, ads, multilingual content, and educational videos, but should not be used for unauthorized voice cloning or impersonation. The best workflow is to rewrite written copy into spoken script, choose the right voice, generate audio in segments, mix it in CapCut or Premiere, add subtitles, and review before publishing.

Originally published on Zyentor Picks.

How to Create High-Quality Product Promo Images with Midjourney: A Complete Prompt Guide

cheng zhang — Thu, 09 Jul 2026 08:02:55 +0000

Category: AI Image Tutorial / Product Promo Visuals

Target readers: e-commerce operators, brand marketers, content creators, designers, independent sellers, and anyone who wants to create product hero images and promotional visuals with AI

Test date: July 9, 2026

Bottom line: Midjourney is excellent for visual concepts, advertising atmosphere, premium product scenes, and creative direction. But it is not the best tool for final commercial layouts with precise Chinese text, prices, logos, and compliance information. The best workflow is to generate a high-quality visual base in Midjourney, then finish layout and text in Canva, Photoshop, or Figma.

1. What Product Promo Images Is Midjourney Good For?

Midjourney’s strength is not final ad layout. Its strength is high-quality visual generation.

It is especially good for:

Scenario	Fit	Notes
E-commerce hero visuals	High	Great for background, lighting, texture, and atmosphere
Social media promo images	High	Good for Xiaohongshu, Instagram, blog, and newsletter visuals
New product concept posters	High	Great for launches, brand storytelling, and mood direction
Independent site banners	High	Clean, premium, international visuals
Product photography simulation	High	Studio, natural light, macro, and lifestyle photography
Chinese text posters	Medium-low	Add final Chinese text in post-production
Accurate logo and packaging text	Medium-low	Use real assets and post-production for final delivery
Consistent SKU batch images	Medium	Use references, Omni Reference, or downstream workflows

In one sentence:

Midjourney is more like an AI photo studio and creative art director than a final layout tool.

2. Which Midjourney Model Should You Use?

As of the test date, Midjourney’s official documentation lists V8.1 as the default version. V8.1 was released on April 30, 2026 and became the default model on June 10, 2026. The documentation says it is the fastest model so far, with standard jobs rendering about 4–5 times faster than earlier versions, and it is better at reading prompts and preserving small details.

Older tutorials about V6 or V7 are not useless. V7 was released in 2025 and introduced Draft Mode and Omni Reference, which can help with image prompts, texture, object details, and object consistency. For product promo images, use the current default V8.1 for general generation, and pay attention to V7 Omni Reference if you need to preserve a specific product or object.

The prompt templates in this article are written to be broadly useful for current Midjourney workflows.

3. The Core Structure of a Product Prompt

Many beginners write prompts like this:

a skincare product, premium, beautiful

That is too vague.

A stronger product prompt should include nine modules:

Module	Role	Example
Product subject	Defines the hero object	a premium matte black perfume bottle
Product features	Material, color, shape	frosted glass, silver cap, minimal label
Use scenario	Adds commercial context	luxury bathroom counter, morning light
Brand mood	Defines tone	clean, elegant, high-end, calming
Camera language	Controls composition	close-up product photography, 85mm lens
Lighting	Defines texture	soft diffused studio lighting
Background	Defines visual hierarchy	beige marble background, subtle reflections
Aspect ratio	Fits the platform	`--ar 4:5`, `--ar 16:9`, `--ar 1:1`
Negative constraints	Removes errors	`--no hands, people, distorted logo, extra text`

Universal template

[product subject], [product features], placed in/on [use scenario],
[brand mood and product benefit atmosphere],
[camera language], [lighting], [background and material],
commercial product photography, premium advertising visual,
clean composition, realistic details, high-end branding
--ar [ratio] --style raw --s [stylize value] --no [unwanted elements]

4. Useful Parameters for Product Images

Midjourney’s official documentation says parameters should be placed at the end of the prompt. They control things such as aspect ratio, style, version, quality, and exclusions.

Parameter	Use	Product image advice
`--ar`	Aspect ratio	1:1 for e-commerce, 3:4 or 4:5 for social, 16:9 for banners
`--s` / `--stylize`	Artistic strength	Use 50–250 for product images
`--raw`	Less default styling	Better for realistic and commercial visuals
`--no`	Exclusions	Remove extra text, hands, distorted logos, clutter
`--seed`	Reproducibility	Useful for series testing
`--repeat`	Multiple generations	Good for fast exploration
`--sref`	Style reference	Keeps a consistent visual theme
`--sw`	Style weight	Controls reference style influence
`--oref`	Omni Reference	Helps preserve a product or object in V7

Aspect ratio guide

Platform	Recommended ratio	Parameter
E-commerce hero image	1:1	`--ar 1:1`
Xiaohongshu cover	3:4 / 4:5	`--ar 3:4` or `--ar 4:5`
Blog / newsletter cover	16:9	`--ar 16:9`
Website banner	21:9 / 16:9	`--ar 21:9` or `--ar 16:9`
Vertical poster	2:3 / 3:4	`--ar 2:3` or `--ar 3:4`

5. Six Copyable Product Promo Prompt Templates

Template 1: Premium studio product shot

Best for skincare, perfume, cups, digital accessories, and premium products.

a premium skincare serum bottle, frosted transparent glass, silver pump cap,
placed on a beige marble surface,
minimal luxury beauty advertising, clean and elegant,
close-up commercial product photography, 85mm lens,
soft diffused studio lighting, subtle reflection, shallow depth of field,
high-end brand visual, realistic texture, clean composition
--ar 4:5 --style raw --s 120 --no people, hands, extra text, distorted label, watermark

Tips:

frosted glass controls material;
soft diffused studio lighting creates a studio look;
--style raw helps keep it commercial rather than overly artistic;
Add final label and logo manually.

Template 2: E-commerce hero image

Best for coffee, drinks, snacks, home goods, and beauty products.

a modern iced coffee bottle, clean cylindrical packaging,
placed in the center of a premium e-commerce hero image,
dark blue gradient background with soft glowing light,
fresh coffee beans and ice cubes around the product,
commercial product photography, sharp focus, realistic reflections,
premium, clean, high conversion product visual
--ar 1:1 --style raw --s 100 --no people, hands, messy background, extra text, fake logo, distorted bottle

Tips:

Keep the hero image clean;
Add price, label, and selling points later;
Use a real product reference when product shape must be accurate.

Template 3: Lifestyle product scene

Best for mugs, tumblers, candles, home goods, fashion, and sports products.

a minimalist white ceramic coffee mug on a wooden desk,
morning sunlight through a window, cozy home office,
open notebook, laptop blurred in background, calm lifestyle mood,
realistic lifestyle product photography, natural light, warm tone,
soft shadows, shallow depth of field, premium editorial style
--ar 4:5 --style raw --s 180 --no people, hands, messy desk, extra text, watermark

Tips:

Lifestyle visuals need a usage scenario;
blurred in background helps create depth;
Use warm tone, cozy, and editorial style for mood.

Template 4: Tech product poster

Best for earbuds, smart watches, phone cases, keyboards, AI hardware, and software visuals.

a sleek wireless earbud case, matte black finish, floating above a dark reflective surface,
futuristic blue light trails, subtle holographic interface elements,
premium technology product advertising, dramatic studio lighting,
sharp edges, clean composition, cinematic contrast,
high-end tech brand campaign visual
--ar 16:9 --style raw --s 200 --no people, hands, random text, distorted product, clutter

Tips:

Tech visuals depend on lighting and background;
Holographic elements may generate fake text, so edit later;
Good for website banners and product launch visuals.

Template 5: Seasonal promotion visual

Best for holiday campaigns, gifts, shopping festivals, Christmas, Valentine’s Day, and Mother’s Day.

a premium gift box product set, elegant red and gold packaging,
placed on a festive holiday table with soft bokeh lights,
luxury seasonal promotion visual, warm cinematic lighting,
clean product-centered composition, realistic materials,
high-end advertising photography, celebration mood
--ar 3:4 --style raw --s 160 --no people, hands, extra words, distorted packaging, watermark

Tips:

Use color, props, and light to show the season;
Add event text later;
Avoid relying on Midjourney for exact Chinese promo copy.

Template 6: Minimal luxury brand visual

Best for high-end beauty, perfume, tea, jewelry, and designer brands.

a luxury perfume bottle with a minimal rectangular shape,
placed on a smooth ivory stone pedestal,
monochrome beige background, elegant negative space,
premium minimalist advertising photography,
soft studio light, subtle shadow, refined texture,
quiet luxury, clean brand campaign visual
--ar 4:5 --style raw --s 80 --no people, hands, text, logo distortion, clutter

Tips:

Minimalism needs fewer elements;
negative space leaves room for typography;
--s 80 keeps the look controlled.

6. Prompt Formulas

Formula 1: Product photography

Product + material + scene + lighting + lens + background + commercial use + parameters

Example:

a premium stainless steel water bottle, brushed metal texture,
on a wet black stone surface, soft studio lighting, 85mm lens,
dark luxury background, commercial product photography
--ar 4:5 --style raw --s 120 --no people, hands, text

Formula 2: E-commerce conversion

Product + visualized benefit + clean background + centered composition + premium lighting + conversion intent + parameters

Example:

a compact portable blender, transparent cup, fresh fruit pieces around it,
centered composition, clean white and green background,
bright commercial lighting, e-commerce hero product image
--ar 1:1 --style raw --s 100 --no people, hands, extra text

Formula 3: Brand mood

Product + brand keywords + scene metaphor + color palette + lighting + negative space + parameters

Example:

a luxury tea canister, calm oriental premium brand mood,
misty mountain silhouette in background, jade green and ivory color palette,
soft morning light, elegant negative space, editorial advertising visual
--ar 3:4 --style raw --s 180 --no text, people, hands

Formula 4: Consistent series

Fixed product description + fixed style words + fixed background system + fixed parameters + seed / style reference

Example:

a premium skincare bottle, frosted glass, silver cap,
minimal beige marble background, soft diffused studio lighting,
luxury beauty advertising, clean composition
--ar 4:5 --style raw --s 100 --seed 20260709

7. How to Make Product Images Look More Commercial

7.1 Describe materials instead of saying “premium”

Use:

frosted glass;
brushed metal;
matte ceramic;
glossy plastic;
transparent acrylic;
natural leather.

7.2 Describe lighting instead of saying “beautiful”

Useful lighting phrases:

soft diffused studio lighting;
natural morning light;
dramatic rim light;
cinematic side lighting;
softbox reflection;
warm golden hour light;
high contrast studio light.

7.3 Describe camera language instead of saying “realistic”

Useful camera phrases:

commercial product photography;
macro photography;
close-up shot;
85mm lens;
shallow depth of field;
sharp focus;
product-centered composition;
editorial advertising photo.

7.4 Leave space for text

Add:

large clean negative space on the top
large empty space on the right side for text
minimal background with room for typography

7.5 Use negative constraints

Common product image issues include extra hands, distorted packaging, fake labels, clutter, and random text.

Use:

--no people, hands, extra text, watermark, distorted logo, deformed packaging, clutter, low quality

8. How to Use References for Product Consistency

If you have a real product photo, do not rely only on text prompts. Midjourney supports multiple reference methods.

8.1 Image Prompt

Use a reference image as part of your prompt to guide product shape, color, and composition.

8.2 Style Reference

Midjourney says Style Reference captures the overall visual vibe of a reference image, such as colors, medium, textures, and lighting. It does not copy objects or people. This is useful for keeping a campaign visually consistent.

Example:

premium skincare product photography, beige marble background, soft luxury lighting --sref [image URL] --sw 150

8.3 Omni Reference

Midjourney says Omni Reference can place a character, object, vehicle, or non-human creature from a reference image into a new generation, and it is compatible with V7. It is useful for preserving a product or object, but fine details like logos may not match perfectly and it costs more GPU time.

Best for:

preserving approximate product shape;
keeping a character;
keeping a specific object form;
making multi-scene visuals for one product.

Not ideal for:

exact trademark reproduction;
exact packaging text;
industrial-grade product consistency;
replacing real product photography.

9. Full Product Image Workflow

Step 1: Prepare inputs

Prepare:

product name;
product category;
core selling points;
target audience;
use scenario;
brand mood;
platform size;
reference product image;
whether final text is needed.

Step 2: Generate visual directions

Do not chase the final image immediately. Generate 4–8 visual directions first.

Example:

a premium portable coffee maker, compact matte white design,
modern kitchen counter, morning sunlight, clean lifestyle photography,
minimal premium brand mood, soft shadows, realistic materials
--ar 4:5 --style raw --s 120 --repeat 2

Step 3: Select and refine

Choose the best direction, then tighten the composition:

same premium portable coffee maker concept,
more centered composition, cleaner background, stronger product focus,
more negative space for headline, soft studio lighting, realistic texture
--ar 4:5 --style raw --s 80

Step 4: Build a series

Image type	Use
Hero image	Product main visual / banner
Lifestyle image	Usage scenario
Detail image	Material, structure, feature
Mood image	Brand atmosphere
Social cover	Xiaohongshu, blog, Instagram
Campaign image	Promotion, holiday, launch

Step 5: Finish in design tools

Use Canva, Photoshop, or Figma for:

logo;
Chinese title;
price;
selling point badges;
promotion info;
cropping;
compliance notes;
real product detail checks.

10. Test Tasks and Scores

Test tasks

Task	Goal
Skincare studio shot	Glass, metal, soft light, luxury feel
Coffee e-commerce image	Centered product, texture, clean background
Smart device poster	Tech lighting and structural stability
Social cover base	Vertical composition and negative space
Holiday gift visual	Seasonal mood and commercial quality
Reference consistency	Product shape retention
Post-production usability	Room for text, cropping, and final layout

Scorecard

Dimension	Score	Notes
Visual quality	95/100	Excellent lighting, composition, and mood
Creative direction	92/100	Great for exploring ad concepts
Product realism	84/100	Good overall, but packaging details need manual checks
Chinese poster readiness	65/100	Do not rely on it for final Chinese text
Series consistency	78/100	References help, but not industrial-level consistency
Post-production usability	88/100	Strong if negative space and composition are controlled
Beginner friendliness	82/100	Easy to learn, but parameters and limits matter

Overall score: 83 / 100

Verdict:

Midjourney is excellent for creative visual bases and premium product atmospheres, but commercial delivery still requires human selection, typography, logo checks, and compliance review.

11. Common Prompt Mistakes

Mistake 1: Only using adjectives

Bad:

premium product image, high-end, beautiful

Better:

a luxury perfume bottle, frosted glass, silver cap,
on beige marble, soft diffused studio lighting,
minimal commercial product photography

Mistake 2: Asking Midjourney to do Chinese layout

Bad:

Create a Chinese poster that says “新品上市 限时优惠”

Better:

Create a product promo background with no text, with large clean space on the right for adding Chinese headline later

Mistake 3: Too much background clutter

Bad:

flowers, clouds, light, people, city, particles, mountains, many decorations

Better:

clean product-centered composition, minimal background, subtle props

Mistake 4: No negative constraints

Bad:

a product advertisement

Better:

a product advertisement --no people, hands, extra text, distorted logo, messy background

Mistake 5: Overusing stylization

Product promo images should not be too artistic. Start with:

--style raw --s 80

Then test 150 or 200 if needed.

12. Commercial Use Notes

Do not treat AI output as a real product photo. If you sell an actual product, check appearance, structure, color, size, and details.
Add logos and packaging text manually. Do not rely on AI to generate precise trademarks or Chinese text.
Avoid competitor-like packaging. Watch for trademark, design patent, and unfair competition risks.
Follow platform rules. E-commerce platforms may regulate main images, efficacy claims, and misleading visuals.
Keep human review. AI images should be reviewed by design, marketing, or legal teams before launch.
Check Midjourney’s terms. Commercial use, privacy, account rules, and output rights should be checked against official terms.

13. Recommended Workflows

E-commerce hero image

Midjourney background and scene → Photoshop real product composite → Canva/Figma selling points → human review → publish

Social media cover

Midjourney visual base → ChatGPT title ideas → Canva layout → A/B test titles

Brand poster

Midjourney moodboard → choose visual direction → generate promo background → designer adds logo and copy

Website banner

Midjourney landscape scene → Figma layout → add CTA button → export compressed WebP

14. Final Verdict

The key to creating high-quality product promo images with Midjourney is not stacking words like “premium,” “cinematic,” and “realistic.” It is breaking the image into controllable modules:

Product subject + material + scene + lighting + lens + background + negative space + parameters + negative constraints.

The most practical prompting mindset is:

Describe what the product is, where it is, what light it uses, what camera style it has, what brand mood it carries, and what platform it is for. Then use parameters to control ratio, style, and exclusions.

Midjourney is best for:

visual ideas;
product atmosphere;
advertising look;
background scenes;
social media cover bases;
e-commerce hero drafts.

But final commercial images still need:

real product checks;
logo compositing;
Chinese typography;
price and selling point verification;
platform rule checks.

One-sentence conclusion:

Use Midjourney to create beautiful commercial visual bases, then use professional design tools to produce accurate, publishable final promo images.

15. SEO Information

SEO title: How to Create High-Quality Product Promo Images with Midjourney: A Complete Prompt Guide

SEO description: This guide explains how to use Midjourney to create product promo images, covering prompt structure, parameters, studio shots, e-commerce hero images, lifestyle scenes, tech posters, seasonal visuals, reference consistency, commercial-use notes, and complete workflows.

Keywords: Midjourney product image, Midjourney prompt, AI product promo image, AI e-commerce hero image, Midjourney tutorial, product photography prompt, AI advertising image, social media cover, e-commerce design, commercial AI art

16. Data Sources and References

Midjourney Version documentation: V8.1 default version, V7 release, Draft Mode, and Omni Reference.

https://docs.midjourney.com/hc/en-us/articles/32199405667853-Version
Midjourney Parameter List: --ar, --no, --raw, --stylize, --sref, --seed, --repeat, and other parameters.

https://docs.midjourney.com/hc/en-us/articles/32859204029709-Parameter-List
Midjourney Style Reference documentation: Style Reference captures the overall visual vibe of a reference image, controlled with --sref and --sw.

https://docs.midjourney.com/hc/en-us/articles/32180011136653-Style-Reference
Midjourney Omni Reference documentation: Omni Reference can bring a person, object, vehicle, or non-human creature from a reference image into new generations, using --oref and --ow.

https://docs.midjourney.com/hc/en-us/articles/36285124473997-Omni-Reference
Midjourney Plans documentation: Basic, Standard, Pro, Mega subscriptions, Fast GPU Time, Relax Mode, and Stealth Mode.

https://docs.midjourney.com/hc/en-us/articles/27870484040333-Comparing-Midjourney-Plans
Midjourney Terms of Service: service quality, assets, inputs, responsibility, and intellectual-property related terms.

https://docs.midjourney.com/hc/en-us/articles/32083055291277-Terms-of-Service

Publish-ready Summary

This guide explains how to create high-quality product promo images with Midjourney. It breaks a product prompt into nine modules: product subject, product features, use scenario, brand mood, camera language, lighting, background, aspect ratio, and negative constraints. It provides copyable templates for studio product shots, e-commerce hero images, lifestyle scenes, tech posters, seasonal promotions, and minimalist luxury visuals. The key conclusion is that Midjourney is excellent for premium commercial visual bases, but final text, logos, prices, selling points, and compliance information should still be completed in Canva, Photoshop, or Figma.

Originally published on Zyentor Picks.