sxth-mind 0.1.0

The understanding layer for adaptive AI products

sxth-mind

The understanding layer for adaptive AI products.

Documentation · Examples · Contributing

---

What is sxth-mind?

sxth-mind is a cognitive state layer for AI applications. It accumulates understanding about users over time—detecting patterns, tracking journey stages, and adapting responses based on derived insights.

Use it to personalize any LLM-powered experience:

• Chat assistants that remember user patterns across sessions
• Personalized dashboards that adapt to user behavior
• Content recommendations informed by journey stage
• Proactive nudges triggered by inactivity or momentum drops
• Any AI feature where understanding should evolve over time

from sxth_mind import Mind
from examples.sales import SalesAdapter

mind = Mind(adapter=SalesAdapter())

# Get user state to personalize any LLM call
state = await mind.get_state("user_1")
# → Use state["user_mind"]["patterns"] to customize prompts, UI, recommendations

# Or use the built-in chat with automatic state management
await mind.chat("user_1", "Following up with the enterprise lead")

Unlike chat history retrieval, sxth-mind maintains derived understanding that evolves with each interaction.

---

Why sxth-mind?

Derived understanding	Not just retrieval—patterns, identity, and journey stage evolve with each interaction
Pluggable everything	Bring your own LLM provider, storage backend, and domain adapter
Framework-agnostic	Works with OpenAI, Anthropic, or any LLM. Not an agent framework—complements them

---

Installation

pip install sxth-mind[openai]      # With OpenAI provider
pip install sxth-mind[api]         # With HTTP API server
pip install sxth-mind[sqlite]      # With SQLite storage
pip install sxth-mind[all]         # Everything

---

Quick Start

import asyncio
from sxth_mind import Mind
from examples.sales import SalesAdapter

async def main():
    mind = Mind(adapter=SalesAdapter())

    # Chat - state accumulates automatically
    response = await mind.chat("user_1", "Working on the Acme deal")
    print(response)

    # Inspect what the Mind knows
    state = await mind.get_state("user_1")
    print(state["user_mind"]["patterns"])

    # Human-readable summary
    print(await mind.explain_state("user_1"))

asyncio.run(main())

---

Features

Core

• Mind — Central abstraction coordinating state, LLM calls, and persistence
• UserMind — User-level identity, patterns, and preferences
• ProjectMind — Context-specific state (deals, habits, learning topics)
• ConversationMemory — Sliding window of recent messages

Adapters

• Domain-specific behavior — Define identity types, journey stages, and nudge templates
• Three examples included — Sales, Habits, Learning
• Build your own — Simple interface, full control

Proactive Intelligence

• Nudge engine — Generate suggestions based on inactivity, momentum drops, patterns
• Journey detection — Automatically track progression through stages
• Pattern recognition — Detect recurring themes and behaviors

Infrastructure

• Pluggable LLM providers — OpenAI included, bring your own
• Pluggable storage — Memory (default), SQLite, or custom
• HTTP API — FastAPI server for service deployment
• CLI — Demo mode and server commands

---

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                           Mind                                   │
│                                                                  │
│   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│   │  UserMind   │  │ ProjectMind │  │   Memory    │            │
│   │  (identity) │  │  (context)  │  │  (history)  │            │
│   └─────────────┘  └─────────────┘  └─────────────┘            │
└───────────────────────────┬─────────────────────────────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        ▼                   ▼                   ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│    Adapter    │   │   Provider    │   │    Storage    │
│  (domain)     │   │  (LLM)        │   │  (persist)    │
└───────────────┘   └───────────────┘   └───────────────┘

---

Example Adapters

Sales

from examples.sales import SalesAdapter
mind = Mind(adapter=SalesAdapter())

Tracks: outreach patterns, deal stages, follow-up frequency

Habits

from examples.habits import HabitCoachAdapter
mind = Mind(adapter=HabitCoachAdapter())

Tracks: streaks, blockers, recovery patterns

Learning

from examples.learning import LearningAdapter
mind = Mind(adapter=LearningAdapter())

Tracks: progress, stuck indicators, learning style

---

Build Your Own Adapter

from sxth_mind import BaseAdapter
from sxth_mind.schemas import ProjectMind

class MyAdapter(BaseAdapter):
    @property
    def name(self) -> str:
        return "my_app"

    def get_identity_types(self):
        return [
            {"key": "power_user", "traits": ["fast", "keyboard-driven"]},
            {"key": "casual", "traits": ["occasional", "exploratory"]},
        ]

    def get_journey_stages(self):
        return [
            {"key": "onboarding", "tone": "helpful"},
            {"key": "proficient", "tone": "efficient"},
        ]

    def detect_journey_stage(self, project_mind: ProjectMind) -> str:
        if project_mind.interaction_count < 5:
            return "onboarding"
        return "proficient"

    def get_nudge_templates(self):
        return {}

See docs/adapters.md for the full guide.

---

HTTP API

sxth-mind serve --adapter sales --port 8000

Method	Endpoint	Description
POST	/chat	Send a message
GET	/state/{user_id}	Get cognitive state
GET	/explain/{user_id}	Human-readable summary
GET	/nudges/{user_id}	Pending nudges

---

What sxth-mind is NOT

• Not an agent framework — We don't plan or execute actions
• Not a vector database — We don't do similarity search
• Not chat history — We store derived understanding, not transcripts

sxth-mind is cognitive infrastructure. You bring the intelligence; we maintain the understanding.

---

Security

sxth-mind is a library you integrate into your application. Authentication, rate limiting, and network security are your responsibility. See SECURITY.md.

---

Contributing

We welcome contributions! See CONTRIBUTING.md.

---

Links

• Documentation
• PyPI
• Changelog
• License (MIT)