YUQI INTELLIGENCE · PRIVATE AI SERVICE

Run language models
on your infrastructure

Yuqi uses Ollama for local deployment, integration and custom development: run models on customer-controlled compute and connect chat and model APIs to existing business systems. Define capabilities, licenses and network boundaries first.

01 Local deployment 02 Model management 03 Enterprise chat 04 Model API access 05 Business integration
yuqi-ai / workspace · Enterprise chat concept Demo
Service ready · Demo
This is a static chat prototype. Replies are preset text, with no connection to a real model.
Sample reply All replies are preset text, not model output CHAR 0 · Demo
DEMO DATA / Interfaces, replies, states and counts are simulated; no model or service is connected Conceptual Ollama deployment solution
Ollama local model deployment — Chinese-language solution illustration
Ollama local model deployment · Illustration in Chinese, not a delivered interface

Interfaces, figures and prices are examples. Actual features, licensing and delivery scope are confirmed for each project.

01 / SCOPE · Define the boundaries

What you receive, what Ollama provides and what we implement

A local inference service and a complete enterprise AI platform have different scopes. Separate customer deliverables, engine capabilities and custom implementation before estimating work and operations.

DELIVERED / Customer outcomes

An operable private inference service

  • Ollama in a customer-controlled environment with model files, startup configuration and service identities
  • Enterprise chat : A chat interface, model selection and conversation records behind agreed authentication
  • Model APIs : Native REST and compatible OpenAI endpoints for business applications
  • Model inventory & operating guide : Versions, sources, weight licenses, upgrades and rollback
  • Tests & handover documents : Functional checks, failure handling, monitoring and acceptance criteria
→ Final scope depends on the agreed custom layer
NATIVE / Ollama capabilities

Model runtime & inference foundation

  • Model retrieval & execution : ollama pull / run / pswith local weight storage
  • REST API: /api/chat、/api/tags with streaming for supported generation endpoints
  • OpenAI compatibility : /v1/chat/completions(a documented subset of the API)
  • Scheduling & memory management : Queues, model loading, CPU/GPU allocation and configured context lengths
  • Model configuration : Modelfile parameters, quantized variants and official Python / JS SDKs
→ Based on the official README, API, hardware and FAQ documentation
CUSTOM / Yuqi implementation

Turn the runtime into a business service

  • Identity, organization & permissions : Authentication, roles, visible models and quotas
  • Knowledge & retrieval : Parsing, chunking, vector storage, RAG orchestration and citations
  • Audit & data governance : Conversation records, sensitive-data policies, exports and retention
  • Multi-user governance : Session isolation, rate limits, queue feedback and usage accounting
  • Integration & operations : Adapters, proxies, TLS, monitoring and recovery
→ Separately designed and implemented beyond the runtime

Ollama does not constitute an enterprise identity, role, audit or knowledge-base platform by itself. These are proposed implementation boundaries. All interfaces and descriptions are illustrative.

02 / CONTEXT · Where it runs

Connect infrastructure to daily work

Local deployment decisions concern where inference runs, who can access it and how it connects to business work. Photos illustrate general settings, not Yuqi or customer installations.

Stock photo of equipment racks and cabling
Customer infrastructure / Inference nodes Local-model deployment uses customer-side hardware; review cloud and external components separately · Illustration
Stock photo of network patch panels and cables
Start with hardware assessment Review GPU compatibility, memory, context and concurrency · Illustration
Stock photo of circuitry and components
Models & compute Weight size, quantization and runtime memory affect loading · Illustration
Stock photo of people in a shared office
Enterprise chat A shared enterprise entry point, rather than individual installations · Illustration
Stock photo of an office with glass partitions
Existing work environment Integrate with existing identity, networks and systems · Illustration
Stock photo of a team meeting
Requirements & acceptance Define users and scenarios before selecting models and hardware · Illustration
PHOTO CREDITS / Nine contextual photos; sources and licensing are recorded below Contextual imagery · Demo
03 / ARCHITECTURE · Four responsibility layers

Entry points → Applications & access → Ollama inference → Models & compute

Select a layer to distinguish runtime capabilities from custom development. Cyan identifies the engine foundation; amber identifies project-specific work.

L0 / ENTRY›

User entry points

Employees, business systems and internal applications initiate chats or API calls. The entry point informs authorization and audit design.

Chat interface · Custom Business systems · Custom Enterprise login · Custom
L1 / APPLICATION & ACCESS›

Applications / Access control

Authentication, roles, quotas, sessions and audit records. Place local inference behind an appropriately controlled application gateway.

RBAC · Custom Audit logs · Custom Knowledge / RAG · Custom Reverse proxy · Custom
L2 / INFERENCE SERVICE›

Ollama inference

Accept requests, queue work, load models and return streamed output where supported. The default listener is local: 127.0.0.1:11434.

/api/chat · Native /v1 subset · Native Scheduling · Native ollama ps · Native
L3 / MODELS & COMPUTE›

Models & compute

Weight files, quantization and licenses. CPU/GPU memory, context length and concurrency must be assessed together.

Weight storage · Native GPU scheduling · Native License review · Delivery Hardware selection · Delivery
04 / REQUEST TRACE · Follow a request

From question to response, one step at a time

Run a simulated request to explore the proposed path. Nodes, logs and ordering are illustrative simulations that explain responsibilities, not real timing or performance.

Illustrative flow · Demo READY / Waiting to start
User question L0 · Demo
Authentication L1 · Custom
Access / Quotas L1 · Custom
Knowledge retrieval L1 · Custom
Gateway forwarding L1 · Custom
Request queue L2 · Native
Model loading L2 · Native
Stream generation L2 / L3
Return & Record L1 · Custom

Why the path includes custom work

  • The default Ollama listener is 127.0.0.1:11434and does not require local API authentication.
  • For the local compatible endpoint, the documented API-key behavior is "api_key ... required but ignored".
  • . Authentication, access rules, limits, audit and knowledge retrieval belong in the L1 application layer and its server-side controls.
  • Requests may be queued when resources are unavailable. Parallelism and context length affect memory use.
  • This demonstration includes no measured timing, throughput or tokens/s claims.
05 / MODEL CONSOLE · Interactive prototype

Model management: versions, licenses and states in one workspace

Switch categories, search, select a row and try loading or unloading. File sizes are examples from official library entries, not measurements from this solution . All runtime states and operations are simulated.

yuqi-ai / model-registry · Concept prototype Demo
Sample data
TABLE / Sample model inventory; listed file sizes are not performance data
MODELParameters File size Weight license State
qwen3:8b8B5.2GBApache 2.0Unloaded
llama3.1:8b8B4.9GBMeta Community License Unloaded
deepseek-r1:8b8B5.2GBWeights MIT* Loaded
gemma3:4b4B3.4GBGemma TermsUnloaded
4 sample records No real model or inference · Demo
DETAIL / Sample model
HARDWARE / Assessment dimensions, not a quote
Assess capacity before loading

Official tags list download sizes, for example about 4.9–5.2 GB for these 8B variants, 43 GB for the 70B example and 404 GB for the 671B example. Runtime memory must also cover context and KV cache.

Assess concurrency & context

The FAQ describes memory growth with parallelism and context length and gives a default of 4096 tokens. Confirm the selected release and configuration; queued requests depend on resource availability.

Check hardware compatibility

The hardware documentation covers NVIDIA compute capability 5.0+ with applicable drivers, AMD ROCm, Apple Metal and Vulkan. Validate the actual device and supported release.

No tokens/s, response latency, universal capacity or hardware recommendation is claimed. Selection depends on the target model, concurrency and real-machine validation.

06 / API · Connect business applications

Two API paths, one local port

These examples follow official API and CLI structures. Switch between REST, compatible OpenAI calls and CLI commands. They are illustrative and are not executed here.

Illustrative example
curl http://localhost:11434/api/tags

Local port & default binding

The default listener is 127.0.0.1:11434. Access from other hosts requires configuring OLLAMA_HOSTand appropriate proxy, TLS and access controls.

Local API access does not require authentication

The compatible-client example describes local api_key as required but ignored. Do not expose port 11434 directly to untrusted networks ; enforce authentication at the gateway and server, beyond interface controls.

Compatibility covers a subset

Official documentation: "Ollama supports a subset of the OpenAI API". Existing SDKs can use a changed base_url, but features relying on broader OpenAI semantics require individual validation.

07 / INTEGRATION · Existing business systems

Connect model capabilities to business actions through defined interfaces

Ollama provides inference APIs, rather than these business-system connectors. Each example needs source-system adapters, permission mapping and failure handling.

01

Internal documents & knowledge

Question answering over policies, manuals and templates. Parsing, chunking, vector storage and source citations require additional implementation.

02

Tickets & support

Draft suggested replies, classifications and summaries within an existing ticket system, using its interfaces and authorization.

03

Spreadsheets & ERP

Map language requests to controlled queries, enforcing authorization before returning data.

04

Development & code

Assist with code suggestions, reviews and internal conventions within repository access and sensitive-data rules.

05

Reports & BI

Draft interpretations for existing dashboards through controlled model calls, with existing source definitions.

06

Portals & messaging

Provide an enterprise portal or IM entry point, with designed identities, sessions and message records.

Stock photo of desks and laptops
Start within existing interfaces Keep employees in their existing tools · Illustration
Stock photo of laptops and collaboration
Multiple devices & users Session isolation and usage accounting require custom work · Illustration
08 / BOUNDARY · Runtime and platform are different scopes

What the runtime includes, and what needs implementation

The left group describes engine functions. The right group requires its own design, development and acceptance work, rather than appearing automatically after installation.

Engine capabilities · Ollama

Based on the official README, API, FAQ and hardware documentation

01Model retrieval, execution & storage CLI and ollama ps for CPU/GPU loading information
02Inference & streaming /api/chat and /api/generate with supported streaming and structured parameters
03Model inventory & metadata /api/tags returns names, sizes, digests and quantization information
04Compatible OpenAI endpoints: subset Adapt existing clients to supported endpoints such as /v1/chat/completions
05Scheduling & memory settings Queues, model loading, context configuration and KV-cache options
06Modelfile & model variants Custom system instructions, parameters and derived model definitions

Custom implementation · Yuqi

These are not included enterprise platform modules

01Knowledge base / RAG Parsing, chunking, vector storage, retrieval, citations and refresh mechanisms
02Users & tenant boundaries Organization mapping, login, session isolation and model access
03Authorization & access control Roles, API authorization, quotas, limits and sensitive-operation approvals
04Audit & operation records Conversation records, redaction, export, retention and deletion policies
05Business integration Adapters for tickets, documents, ERP, BI and enterprise portals
06Production operations Proxies, TLS, monitoring, logs, backups, upgrades and rollback
09 / DELIVERY · Assessment to handover

Six stages, each with reviewable outputs

This illustrates a delivery approach, without project schedules, prices or performance commitments. Hardware and model decisions require real-machine validation.

STEP 01

Hardware assessment

Review model size, context, concurrency and GPU compatibility, then record validation on the target device.

Output: hardware assessment
STEP 02

Deployment

Install Ollama in the agreed environment, with service identities, model storage, listener and network policy.

Output: deployment configuration
STEP 03

Model selection

Compare models for the scenario and review each tag's weight license, quantization and context capabilities.

Output: model & license inventory
STEP 04

API integration

Implement chat, gateways, authorization and business adapters, with separately scoped knowledge integration where required.

Output: operable application
STEP 05

Testing

Validate functional paths, queues, failures, authorization and outbound network behavior.

Output: test report
STEP 06

Operations handover

Hand over monitoring, logs, audit arrangements, recovery, upgrade rollback and operating guides.

Output: operating guide & acceptance checklist
Stock photo of colleagues discussing work at a desk
Delivery goes beyond starting a service Handover includes acceptance criteria, operating guides, upgrades and rollback · Illustration
10 / LICENSING · Review engine and weights separately

The engine is MIT; model weights have their own terms

Software and weight licensing are separate. These examples were reviewed against official repositories and model entries on 2026-11-15. Before commercial delivery, review every selected tag again against its actual files and terms.

ENGINE / Runtime
Ollama software · MIT License

The software license permits use, modification and distribution subject to its notices and terms, without warranty. It does not license model weights.

Qwen3Apache 2.0

The Qwen3 README states Apache-2.0 for its open weights and directs users to the individual model repositories for license files.

Meta Llama 3.1Community License

Llama 3.1 uses Meta's Community License, including its additional commercial threshold, acceptable-use rules and applicable attribution and notice requirements.

DeepSeek-R1Weights MIT*

DeepSeek states MIT for its weights, while derived variants need review of the actual base, model card and applicable terms. Different tags in one family can have different obligations.

Gemma 3Gemma Terms

Gemma models use Google's Gemma Terms of Use, rather than the MIT or Apache-2.0 license.

Define offline and outbound-data boundaries precisely

  • Remote retrieval needs connectivity; offline provisioning needs a separate plan Remote pulls and updates access a registry. Controlled offline provisioning requires source, integrity and license checks.
  • The default listener is local The default binding is 127.0.0.1:11434. Cross-host access requires explicit listener and network configuration.
  • Local-only mode is not a firewall OLLAMA_NO_CLOUD=1 disables cloud models and web search; it is not documented as blocking every outbound request.
  • Cloud features change data paths Cloud-hosted inference processes prompts and responses and has its own usage-metadata and privacy arrangements.
  • Review third-party components separately Integrations, monitoring, updates, DNS, log shipping and plugins may create outbound connections.
  • Verify during handover Record egress rules, allowlists, cloud settings, logs and model sources in acceptance criteria, rather than relying on a blanket offline claim.
The FAQ distinguishes local processing from disabling cloud functionality. Neither statement guarantees the behavior of every connected component.
→ These statements describe local execution and cloud settings; they do not guarantee that data never leaves under every configuration .

No customer cases, business results, tokens/s or latency measurements are represented. Interfaces, answers, metrics, logs and flows are simulated.

NEXT STEP

Agree scope, licensing and hardware first

Start with users, connected systems, network policy and model terms, rather than the largest model. This page introduces a proposed approach and performs no deployment.

This local demonstration installs no software, retrieves no models, starts no inference service, connects no backend and performs no deployment.