Metadata-Version: 2.4
Name: pinuxd
Version: 0.2.0
Summary: Pinuxd — the intellective layer: an operating system for enterprise AI (knowledge graph, governed workflows, cost governor, provable multi-tenant isolation).
Author-email: Mohit Deepak Soni <mohitdeepaksoni@gmail.com>
Maintainer-email: Mohit Deepak Soni <mohitdeepaksoni@gmail.com>
License: Proprietary
Keywords: knowledge-graph,graphrag,semantic-layer,enterprise-ai,governed-ai,agents,workflow-engine,rag,multi-tenant,cost-optimization
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Information Technology
Classifier: License :: Other/Proprietary License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Requires-Python: >=3.9
Description-Content-Type: text/markdown
Requires-Dist: antahkarana>=8.0.0
Provides-Extra: kuzu
Requires-Dist: kuzu>=0.4; extra == "kuzu"
Provides-Extra: dev
Requires-Dist: pytest>=7; extra == "dev"

# Pinuxd

**The intellective layer — an operating system for enterprise AI.**

Pinuxd is the backbone that decides *how* an organization uses AI across its data, documents, events,
models, and compute — grounded in a knowledge graph, governed end to end, and continuously optimized for
**accuracy ↑, speed ↑, cost ↓**.

Not a chatbot, not a framework, not a model. An **operating system**: it owns the scheduling, memory,
security, I/O, and processes for AI the way a kernel owns them for a computer — so you build *on* it instead
of re-wiring an agent framework + a vector database + a rules engine + a governance bolt-on for the tenth
time.

> **Commercial software — free for 90 days.** After the trial a license key is required.
> For a license key, contact **mohitdeepaksoni@gmail.com**.

---

## Install

```bash
pip install pinuxd
```

## What you get

| Plane | Capability |
|---|---|
| **Ontology & knowledge graph** | A typed, governed **ontology** — object types, link types, and action types with validated properties — over a property graph, a business glossary, entity resolution, and **GraphRAG**. Machine-checked conformance keeps the live data true to the model. Swap the ontology and the same platform serves a new use case (service desk, code, documents, finance). |
| **Data & document fabric** | Connectors, multi-modal ingestion (text/table/image/audio), incremental ETL into the graph with provenance and provable freshness. |
| **Cost governor** | A semantic cache, a reranker, and cheap-first **learned-and-gated** routing that serves the cheapest path clearing an accuracy bar — with the accuracy floor enforced at execution. |
| **Workflow & event engine** | Durable, resumable, event-driven workflows with human-in-the-loop, saga compensation, SLAs, and exactly-once across a crash/failover. |
| **Policy & rules engine** | RBAC, rules-as-constraints, living-policy binding, and a **machine-checked proof of zero rule violations**. |
| **Enterprise hardening** | **Provable multi-tenant isolation**, observability, quotas, deploy/DR, air-gap, and an admin console. |

## Who it's for — customer use cases

Pinuxd is a horizontal platform. It is built for teams putting AI into production where **accuracy, cost,
and governance all matter at once** — not demos. Typical customers:

- **Customer support & IT service teams.** Ground answers across your ticketing, roster, and org systems
  (GraphRAG connects a ticket → the engineer who fixed it → their manager → the SLA), let agents take
  *governed* actions (auto-allow small refunds, escalate large ones to a human, deny the rest), and answer
  most tickets with a cheap model or a cached response so only the hard ones cost more.

- **Financial operations & analytics teams.** Bind "revenue", "active customer", and "MRR" to the
  organization's *exact* definitions via the business glossary, so answers stop drifting with the model's
  guess — and every figure traces back through lineage to its source record for audit.

- **Compliance, legal & risk teams.** Encode policy as executable rules; bind a rule to a living policy
  document so a rephrase reconciles automatically and a contradiction is quarantined for a human — the
  compliance rule never silently changes because the document did. The rule set is machine-checked for
  zero violations.

- **Field operations & back-office automation.** Run long, multi-step processes (inspect → order → approve
  → dispatch) as durable workflows that survive restarts, resume exactly once, wait for real-world events,
  and roll back cleanly on failure.

- **AI SaaS & platform teams (multi-tenant).** Serve many customers on one deployment with **provable**
  tenant isolation, per-tenant quotas, full observability, and air-gapped / on-prem operation on CPU or GPU.

**When Pinuxd fits:** you need grounded, multi-hop answers over your own data; you want to cut model cost
without losing accuracy; you must *prove* that rules and tenant boundaries hold; or you run long-lived,
governed processes that cannot lose their place. **When it doesn't:** a single-prompt chatbot with no data,
governance, or cost constraints — you don't need an operating system for that.

## Quickstart

**Define an ontology — typed objects, links, and actions — and keep the live data provably true to it** *(new in 0.2)*:

```python
from pinuxd import InMemoryGraphBackend, EntityResolver, Glossary, Ontology, PropSpec

onto = Ontology(graph=InMemoryGraphBackend(), resolver=EntityResolver(...), glossary=Glossary())

onto.object_type("ticket", props=[PropSpec("name", "str", required=True),
                                  PropSpec("priority", "enum", enum=("low", "high"))])
onto.object_type("engineer", props=[PropSpec("name", "str", required=True)])
onto.link_type("fixed_by", "ticket", "engineer")
onto.action_type("refund", applies_to="ticket", permission="billing:refund")

t = onto.create("ticket", "T-12", name="T-12", priority="high")
a = onto.create("engineer", "Alice", name="Alice")
onto.link("fixed_by", t, a)

report = onto.validate()      # machine-checked conformance: every object & link obeys the schema
assert report.ok              # required props present, types & enums valid, link endpoints correct
```

Swap that ontology and the **same platform** — GraphRAG, cost governor, policy, workflows, isolation —
serves an entirely different use case (documents, code, finance, compliance, media) unchanged.

**Answer a multi-hop question flat retrieval cannot reach**, over the same graph:

```python
from pinuxd import GraphRAG

ctx = GraphRAG(onto.graph, resolver=onto.resolver, k_hops=2).retrieve(
    "who manages the engineer who fixed T-12?")
print(ctx.to_text())          # grounded, cited triples walked across the graph
```

Route requests for cost while holding an accuracy bar:

```python
from pinuxd import CostGovernor, Tier

gov = CostGovernor(
    tiers=[Tier("skill", 0, handler=skill_fn), Tier("small", 1, handler=small_llm),
           Tier("large", 8, handler=large_llm)],
    scorer=accuracy_fn, accuracy_bar=0.7)
gov.ask("summarize this ticket")
print(gov.report().savings)     # cheapest path that clears the bar; savings vs all-strongest
```

Prove your guarantees:

```python
from pinuxd import check_policy, check_isolation
assert check_policy().ok        # zero rule violations over the full state space (machine-checked)
assert check_isolation().ok     # no cross-tenant access over the full state space (machine-checked)
```

## Design principles

- **Governed by construction** — every data/model/tool call flows through a non-bypassable control plane and
  is audited; the guarantees that matter are **machine-checked**, not asserted.
- **Parallel-first** — expensive work runs concurrently; only critical mutations are serialized.
- **Highly available** — replicated, quorum-based journal and vector storage; survives a node down; self-heals.
- **CPU or GPU** — the same code runs on CPU, NVIDIA (CUDA), or AMD (ROCm).
- **Vendor-neutral** — any model, any vector store, any knowledge-graph engine, via clean seams.

## Licensing

Commercial software with a **90-day free trial**, then a signed license key (Ed25519; verified offline).
The customer CLI ships with the package:

```bash
pinuxd-license status               # trial/license status
pinuxd-license install "<KEY>"      # install a purchased key
```

Enforce it at start-up:

```python
from pinuxd.licensing import LicenseManager
LicenseManager().require()          # raises when a key is required, with the contact address
```

**For a license key or commercial enquiries: mohitdeepaksoni@gmail.com**

---

© Mohit Deepak Soni. All rights reserved. Proprietary — see the licensing terms.
