phantomreason 0.1.0__tar.gz

phantomreason-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PhantomTrace Agent Maintainers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

phantomreason-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+include seed_lexicon.txt
+recursive-include deployment *.example

phantomreason-0.1.0/PKG-INFO

@@ -0,0 +1,283 @@
+Metadata-Version: 2.4
+Name: phantomreason
+Version: 0.1.0
+Summary: Symbolic AI reasoning engine built on PhantomTrace absence arithmetic. Trace-based memory, fact management, and semantic retrieval for standalone use or as an augmentation layer over LLMs.
+Author: PhantomTrace Agent Maintainers
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/phantomtrace/phantomreason
+Project-URL: Documentation, https://github.com/phantomtrace/phantomreason#readme
+Project-URL: Repository, https://github.com/phantomtrace/phantomreason
+Project-URL: Issues, https://github.com/phantomtrace/phantomreason/issues
+Keywords: phantomtrace,phantomreason,symbolic-ai,reasoning,memory,agent,absence-arithmetic,trace-vector,fact-store,llm-augmentation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: absence-calculator>=0.5.0
+Dynamic: license-file
+
+# PhantomReason
+
+A symbolic AI reasoning engine built on [PhantomTrace](https://pypi.org/project/absence-calculator/) absence arithmetic.
+
+PhantomReason is not a neural network. It represents knowledge as sparse binary vectors where each dimension is either *present* or *absent* -- the two fundamental states of PhantomTrace arithmetic. Learning happens by toggling these states through the same operations that define the algebra: `combine`, `compare`, `add`, `erase`, and `toggle`.
+
+The result is a lightweight symbolic system that can store facts, answer questions, parse sentence structure, and generate constrained text -- all without gradient descent, matrix multiplication, or floating-point weights.
+
+## Why This Exists
+
+Large language models are powerful but opaque. They hallucinate, forget instructions, and offer no mechanism to inspect *why* they produced a given answer.
+
+PhantomReason takes a different approach:
+
+- **Every fact has a traceable strength** stored as a PhantomTrace number. You can inspect it, reinforce it with `add`, weaken it with `erase`, and watch it decay over time.
+- **Predictions are distance-based.** The model ranks candidates by how close their trace vectors are to the current context. The scoring is transparent and deterministic.
+- **Contradictions are resolved symbolically.** When a new fact conflicts with an old one, the old fact's strength is erased rather than silently overwritten.
+- **Memory is explicit.** Episodes, facts, and symbols each have their own trace store with named banks. Nothing is hidden in a billion-parameter matrix.
+
+This makes PhantomReason suitable as a standalone symbolic reasoner for constrained domains, or as an **augmentation layer** that can sit alongside an LLM to provide grounded fact memory, symbolic confidence tracking, and interpretable retrieval.
+
+## Installation
+
+```bash
+pip install phantomreason
+```
+
+Requires Python 3.11+ and [`absence-calculator`](https://pypi.org/project/absence-calculator/) (installed automatically).
+
+## Performance
+
+Initial model setup involves computing sparse trace vectors for the vocabulary and training corpus. On a typical machine:
+
+| Operation | Time |
+|-----------|------|
+| Import + model init (dim=512) | ~1-2 seconds |
+| Training on a few sentences | ~30-40 seconds |
+| Subsequent startup with persisted state | ~3-5 seconds |
+| Individual predictions | <1 second (warm cache) |
+| `route_prompt` queries | 0.1-4 seconds |
+
+The first run is the slowest because trace vectors must be computed for every word in the training data. After the model saves its state, restarts are fast because the vectors are loaded from disk rather than recomputed.
+
+## Quick Start
+
+```python
+from phantomreason import PhantomLanguageModel
+
+model = PhantomLanguageModel(dim=512, sparsity=47)
+
+model.train_on_text(
+    "aurora paints dawn softly. chefs simmer herbs slowly. "
+    "gardeners water orchids gently.",
+    epochs=1,
+)
+
+model.register_fact("chefs", "simmer", ["herbs", "slowly"])
+model.register_fact("gardeners", "water", ["orchids", "gently"])
+
+routed = model.route_prompt("what do chefs simmer?")
+print(routed["fact_answer"])  # "herbs slowly"
+print(routed["sample"])       # "chefs simmer herbs slowly."
+
+prediction = model.predict_next(model.tokenize("aurora paints"))
+print(prediction)  # "dawn"
+```
+
+**Note on fact recall:** `route_prompt` matches the question's predicate against stored fact predicates. The predicate in the question must match the stored form exactly (e.g., ask "what do chefs simmer?" not "what does chef simmer?"). Verb form normalization covers common auxiliaries (is/are/was/were) but not all inflections.
+
+## Core Concepts
+
+### Trace Vectors
+
+Every word the model knows is represented as a sparse vector of `AbsentNumber` objects. Each slot is either *present* (the word is associated with that dimension) or *absent* (it is not). The vector has a fixed number of present slots controlled by the `sparsity` parameter.
+
+### Operations
+
+All reasoning uses PhantomTrace operations from the `absence-calculator` library:
+
+| Operation | PhantomTrace | Use in Agent |
+|-----------|-------------|--------------|
+| `combine(a, b)` | State overlap | Building context signatures from word vectors |
+| `compare(a, b)` | Directional difference | Measuring distance between vectors |
+| `add(a, b)` | State accumulation | Composing semantic probes, strengthening facts |
+| `erase(a, b)` | State removal with flip | Weakening facts, resolving contradictions |
+| `toggle(x)` | Flip present/absent | Learning updates, vector modification |
+| `n(value)` | Create a present number | Fact strength initialization |
+
+### Trace Stores
+
+The model maintains four separate trace stores:
+
+- **Trace store** -- word vectors with context and topic memory banks
+- **Symbol store** -- intent, action, form, and role classifications
+- **Episode store** -- interaction history for episodic memory retrieval
+- **Fact store** -- subject-predicate-object triples with forward and inverse lookup
+
+Each store holds a primary vector and one or more named banks per entry, all subject to the same sparsity constraint.
+
+### Fact Lifecycle
+
+Facts have a strength value stored as a PhantomTrace `AbsentNumber`:
+
+1. A new fact starts with strength `n(1)` -- a present 1.
+2. Teaching the same fact again adds `n(1)` to its strength.
+3. A contradicting fact (same subject + predicate, different object) erases the old fact's strength.
+4. Periodic decay erases `n(1)` from old facts, letting stale knowledge fade.
+5. A fact becomes inactive when its strength drops to an absent state.
+
+This mirrors how PhantomTrace arithmetic treats presence and absence: knowledge does not disappear, it transitions from present to absent.
+
+## Training and Ingestion
+
+```python
+model.train_on_text("gardeners water orchids gently.", epochs=1)
+
+model.ingest_text_corpus(long_text, trace_budget_per_sentence=96)
+
+model.ingest_file("corpus.txt")
+
+model.ingest_url("https://example.com/article")
+```
+
+The `seed_lexicon.txt` file included in the repository provides 60 dictionary-style definitions that bootstrap the model's vocabulary and fact base. Ingesting the full lexicon at dim=512 takes several minutes.
+
+## HTTP Service
+
+PhantomReason includes an HTTP service:
+
+```bash
+phantomreason-serve --host 127.0.0.1 --port 8080 --dim 512 --sparsity 47
+```
+
+Or with authentication:
+
+```bash
+export PHANTOM_AGENT_API_TOKEN='your-secret-token'
+phantomreason-serve --host 127.0.0.1 --port 8080
+```
+
+### Endpoints
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| `GET` | `/health` | No | Service and model status |
+| `GET` | `/evaluate` | Yes | Run the built-in evaluation harness |
+| `POST` | `/query` | Yes | Route a prompt through the reasoning pipeline |
+| `POST` | `/teach` | Yes | Train on new text |
+| `POST` | `/ingest` | Yes | Ingest text, file, or URL |
+| `POST` | `/focus` | Yes | Set focus mode or focus text |
+| `POST` | `/checkpoint` | Yes | Save model state to disk |
+
+### Example Requests
+
+```bash
+# Query
+curl -X POST http://localhost:8080/query \
+  -H "Authorization: Bearer $PHANTOM_AGENT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "what do chefs simmer?"}'
+
+# Teach
+curl -X POST http://localhost:8080/teach \
+  -H "Authorization: Bearer $PHANTOM_AGENT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "vector means an ordered list used for state", "epochs": 1}'
+
+# Ingest from URL
+curl -X POST http://localhost:8080/ingest \
+  -H "Authorization: Bearer $PHANTOM_AGENT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://example.com/article"}'
+```
+
+## Data Storage
+
+Runtime state is stored in the current working directory by default:
+
+- `words` -- the learned vocabulary, one word per line
+- `phantom_model_state.json` -- all vectors, banks, facts, episodes, and symbols
+
+Set `PHANTOM_DATA_DIR` to store state in a custom location:
+
+```bash
+export PHANTOM_DATA_DIR=/var/lib/phantomreason
+phantomreason-serve --host 127.0.0.1 --port 8080
+```
+
+## Evaluation
+
+Run the built-in evaluation harness to verify the model works correctly:
+
+```bash
+phantomreason-eval
+```
+
+This tests fact recall, contradiction handling, decay behavior, and sentence parsing.
+
+## As an LLM Augmentation Layer
+
+PhantomReason is designed to complement large language models, not replace them. A future integration package can use the agent as:
+
+- **A grounded fact store.** Teach the agent verified facts and query it before passing context to an LLM. The agent's symbolic confidence scores tell you which facts are reliable.
+- **A contradiction detector.** When new information conflicts with stored knowledge, the agent's erasure mechanics make the conflict explicit rather than silently overwriting.
+- **An interpretable memory layer.** The agent's trace vectors and fact strengths are fully inspectable -- you can trace *why* a particular answer was retrieved.
+- **A retrieval filter.** Use the agent's `rank_candidates` and `retrieve_fact` to select relevant context for an LLM prompt, with transparent distance scores.
+
+The boundary is clean: PhantomReason handles memory, confidence, and symbolic retrieval. The LLM handles natural language generation and broad world knowledge.
+
+## Interactive Mode
+
+For experimentation and debugging:
+
+```bash
+python -c "from phantomreason import PhantomLanguageModel, run_interactive_test; run_interactive_test(PhantomLanguageModel(dim=512, sparsity=47))"
+```
+
+The first run takes 30-40 seconds while trace vectors are computed. Subsequent runs with persisted state start in under 5 seconds.
+
+Commands in interactive mode:
+
+| Command | Description |
+|---------|-------------|
+| `teach <text>` | Train on new text |
+| `ingest <file>` | Ingest a local text file |
+| `scrape <url>` | Ingest from a URL |
+| `focus <text>` | Prime focus mode on specific text |
+| `focus on` / `focus off` | Toggle focus mode |
+| `inspect <prompt>` | Show the top-ranked candidate and its trace comparison |
+| Any other text | Route through the full reasoning pipeline |
+
+## Project Structure
+
+```
+phantomreason/
+  __init__.py       Package exports
+  model.py          Core reasoning engine (PhantomLanguageModel)
+  traces.py         PhantomTrace operation wrappers
+  stores.py         Sparse trace vector storage (TraceStore)
+  storage.py        Vocabulary and state path management
+  corpus.py         Text normalization, sentence splitting, URL fetching
+  service.py        HTTP service with auth and metrics
+  evaluate.py       Built-in evaluation harness
+```
+
+## Requirements
+
+- Python 3.11+
+- [`absence-calculator`](https://pypi.org/project/absence-calculator/) >= 0.5.0
+
+No other dependencies. No PyTorch, TensorFlow, NumPy, or any ML framework.
+
+## License
+
+MIT

phantomreason-0.1.0/README.md

@@ -0,0 +1,255 @@
+# PhantomReason
+
+A symbolic AI reasoning engine built on [PhantomTrace](https://pypi.org/project/absence-calculator/) absence arithmetic.
+
+PhantomReason is not a neural network. It represents knowledge as sparse binary vectors where each dimension is either *present* or *absent* -- the two fundamental states of PhantomTrace arithmetic. Learning happens by toggling these states through the same operations that define the algebra: `combine`, `compare`, `add`, `erase`, and `toggle`.
+
+The result is a lightweight symbolic system that can store facts, answer questions, parse sentence structure, and generate constrained text -- all without gradient descent, matrix multiplication, or floating-point weights.
+
+## Why This Exists
+
+Large language models are powerful but opaque. They hallucinate, forget instructions, and offer no mechanism to inspect *why* they produced a given answer.
+
+PhantomReason takes a different approach:
+
+- **Every fact has a traceable strength** stored as a PhantomTrace number. You can inspect it, reinforce it with `add`, weaken it with `erase`, and watch it decay over time.
+- **Predictions are distance-based.** The model ranks candidates by how close their trace vectors are to the current context. The scoring is transparent and deterministic.
+- **Contradictions are resolved symbolically.** When a new fact conflicts with an old one, the old fact's strength is erased rather than silently overwritten.
+- **Memory is explicit.** Episodes, facts, and symbols each have their own trace store with named banks. Nothing is hidden in a billion-parameter matrix.
+
+This makes PhantomReason suitable as a standalone symbolic reasoner for constrained domains, or as an **augmentation layer** that can sit alongside an LLM to provide grounded fact memory, symbolic confidence tracking, and interpretable retrieval.
+
+## Installation
+
+```bash
+pip install phantomreason
+```
+
+Requires Python 3.11+ and [`absence-calculator`](https://pypi.org/project/absence-calculator/) (installed automatically).
+
+## Performance
+
+Initial model setup involves computing sparse trace vectors for the vocabulary and training corpus. On a typical machine:
+
+| Operation | Time |
+|-----------|------|
+| Import + model init (dim=512) | ~1-2 seconds |
+| Training on a few sentences | ~30-40 seconds |
+| Subsequent startup with persisted state | ~3-5 seconds |
+| Individual predictions | <1 second (warm cache) |
+| `route_prompt` queries | 0.1-4 seconds |
+
+The first run is the slowest because trace vectors must be computed for every word in the training data. After the model saves its state, restarts are fast because the vectors are loaded from disk rather than recomputed.
+
+## Quick Start
+
+```python
+from phantomreason import PhantomLanguageModel
+
+model = PhantomLanguageModel(dim=512, sparsity=47)
+
+model.train_on_text(
+    "aurora paints dawn softly. chefs simmer herbs slowly. "
+    "gardeners water orchids gently.",
+    epochs=1,
+)
+
+model.register_fact("chefs", "simmer", ["herbs", "slowly"])
+model.register_fact("gardeners", "water", ["orchids", "gently"])
+
+routed = model.route_prompt("what do chefs simmer?")
+print(routed["fact_answer"])  # "herbs slowly"
+print(routed["sample"])       # "chefs simmer herbs slowly."
+
+prediction = model.predict_next(model.tokenize("aurora paints"))
+print(prediction)  # "dawn"
+```
+
+**Note on fact recall:** `route_prompt` matches the question's predicate against stored fact predicates. The predicate in the question must match the stored form exactly (e.g., ask "what do chefs simmer?" not "what does chef simmer?"). Verb form normalization covers common auxiliaries (is/are/was/were) but not all inflections.
+
+## Core Concepts
+
+### Trace Vectors
+
+Every word the model knows is represented as a sparse vector of `AbsentNumber` objects. Each slot is either *present* (the word is associated with that dimension) or *absent* (it is not). The vector has a fixed number of present slots controlled by the `sparsity` parameter.
+
+### Operations
+
+All reasoning uses PhantomTrace operations from the `absence-calculator` library:
+
+| Operation | PhantomTrace | Use in Agent |
+|-----------|-------------|--------------|
+| `combine(a, b)` | State overlap | Building context signatures from word vectors |
+| `compare(a, b)` | Directional difference | Measuring distance between vectors |
+| `add(a, b)` | State accumulation | Composing semantic probes, strengthening facts |
+| `erase(a, b)` | State removal with flip | Weakening facts, resolving contradictions |
+| `toggle(x)` | Flip present/absent | Learning updates, vector modification |
+| `n(value)` | Create a present number | Fact strength initialization |
+
+### Trace Stores
+
+The model maintains four separate trace stores:
+
+- **Trace store** -- word vectors with context and topic memory banks
+- **Symbol store** -- intent, action, form, and role classifications
+- **Episode store** -- interaction history for episodic memory retrieval
+- **Fact store** -- subject-predicate-object triples with forward and inverse lookup
+
+Each store holds a primary vector and one or more named banks per entry, all subject to the same sparsity constraint.
+
+### Fact Lifecycle
+
+Facts have a strength value stored as a PhantomTrace `AbsentNumber`:
+
+1. A new fact starts with strength `n(1)` -- a present 1.
+2. Teaching the same fact again adds `n(1)` to its strength.
+3. A contradicting fact (same subject + predicate, different object) erases the old fact's strength.
+4. Periodic decay erases `n(1)` from old facts, letting stale knowledge fade.
+5. A fact becomes inactive when its strength drops to an absent state.
+
+This mirrors how PhantomTrace arithmetic treats presence and absence: knowledge does not disappear, it transitions from present to absent.
+
+## Training and Ingestion
+
+```python
+model.train_on_text("gardeners water orchids gently.", epochs=1)
+
+model.ingest_text_corpus(long_text, trace_budget_per_sentence=96)
+
+model.ingest_file("corpus.txt")
+
+model.ingest_url("https://example.com/article")
+```
+
+The `seed_lexicon.txt` file included in the repository provides 60 dictionary-style definitions that bootstrap the model's vocabulary and fact base. Ingesting the full lexicon at dim=512 takes several minutes.
+
+## HTTP Service
+
+PhantomReason includes an HTTP service:
+
+```bash
+phantomreason-serve --host 127.0.0.1 --port 8080 --dim 512 --sparsity 47
+```
+
+Or with authentication:
+
+```bash
+export PHANTOM_AGENT_API_TOKEN='your-secret-token'
+phantomreason-serve --host 127.0.0.1 --port 8080
+```
+
+### Endpoints
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| `GET` | `/health` | No | Service and model status |
+| `GET` | `/evaluate` | Yes | Run the built-in evaluation harness |
+| `POST` | `/query` | Yes | Route a prompt through the reasoning pipeline |
+| `POST` | `/teach` | Yes | Train on new text |
+| `POST` | `/ingest` | Yes | Ingest text, file, or URL |
+| `POST` | `/focus` | Yes | Set focus mode or focus text |
+| `POST` | `/checkpoint` | Yes | Save model state to disk |
+
+### Example Requests
+
+```bash
+# Query
+curl -X POST http://localhost:8080/query \
+  -H "Authorization: Bearer $PHANTOM_AGENT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "what do chefs simmer?"}'
+
+# Teach
+curl -X POST http://localhost:8080/teach \
+  -H "Authorization: Bearer $PHANTOM_AGENT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "vector means an ordered list used for state", "epochs": 1}'
+
+# Ingest from URL
+curl -X POST http://localhost:8080/ingest \
+  -H "Authorization: Bearer $PHANTOM_AGENT_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://example.com/article"}'
+```
+
+## Data Storage
+
+Runtime state is stored in the current working directory by default:
+
+- `words` -- the learned vocabulary, one word per line
+- `phantom_model_state.json` -- all vectors, banks, facts, episodes, and symbols
+
+Set `PHANTOM_DATA_DIR` to store state in a custom location:
+
+```bash
+export PHANTOM_DATA_DIR=/var/lib/phantomreason
+phantomreason-serve --host 127.0.0.1 --port 8080
+```
+
+## Evaluation
+
+Run the built-in evaluation harness to verify the model works correctly:
+
+```bash
+phantomreason-eval
+```
+
+This tests fact recall, contradiction handling, decay behavior, and sentence parsing.
+
+## As an LLM Augmentation Layer
+
+PhantomReason is designed to complement large language models, not replace them. A future integration package can use the agent as:
+
+- **A grounded fact store.** Teach the agent verified facts and query it before passing context to an LLM. The agent's symbolic confidence scores tell you which facts are reliable.
+- **A contradiction detector.** When new information conflicts with stored knowledge, the agent's erasure mechanics make the conflict explicit rather than silently overwriting.
+- **An interpretable memory layer.** The agent's trace vectors and fact strengths are fully inspectable -- you can trace *why* a particular answer was retrieved.
+- **A retrieval filter.** Use the agent's `rank_candidates` and `retrieve_fact` to select relevant context for an LLM prompt, with transparent distance scores.
+
+The boundary is clean: PhantomReason handles memory, confidence, and symbolic retrieval. The LLM handles natural language generation and broad world knowledge.
+
+## Interactive Mode
+
+For experimentation and debugging:
+
+```bash
+python -c "from phantomreason import PhantomLanguageModel, run_interactive_test; run_interactive_test(PhantomLanguageModel(dim=512, sparsity=47))"
+```
+
+The first run takes 30-40 seconds while trace vectors are computed. Subsequent runs with persisted state start in under 5 seconds.
+
+Commands in interactive mode:
+
+| Command | Description |
+|---------|-------------|
+| `teach <text>` | Train on new text |
+| `ingest <file>` | Ingest a local text file |
+| `scrape <url>` | Ingest from a URL |
+| `focus <text>` | Prime focus mode on specific text |
+| `focus on` / `focus off` | Toggle focus mode |
+| `inspect <prompt>` | Show the top-ranked candidate and its trace comparison |
+| Any other text | Route through the full reasoning pipeline |
+
+## Project Structure
+
+```
+phantomreason/
+  __init__.py       Package exports
+  model.py          Core reasoning engine (PhantomLanguageModel)
+  traces.py         PhantomTrace operation wrappers
+  stores.py         Sparse trace vector storage (TraceStore)
+  storage.py        Vocabulary and state path management
+  corpus.py         Text normalization, sentence splitting, URL fetching
+  service.py        HTTP service with auth and metrics
+  evaluate.py       Built-in evaluation harness
+```
+
+## Requirements
+
+- Python 3.11+
+- [`absence-calculator`](https://pypi.org/project/absence-calculator/) >= 0.5.0
+
+No other dependencies. No PyTorch, TensorFlow, NumPy, or any ML framework.
+
+## License
+
+MIT

phantomreason-0.1.0/deployment/nginx.conf.example

@@ -0,0 +1,21 @@
+server {
+    listen 443 ssl http2;
+    server_name phantom-agent.example.com;
+
+    ssl_certificate /etc/letsencrypt/live/phantom-agent.example.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/phantom-agent.example.com/privkey.pem;
+
+    client_max_body_size 256k;
+
+    location / {
+        proxy_pass http://127.0.0.1:8080;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header Connection "";
+        proxy_read_timeout 60s;
+        proxy_send_timeout 60s;
+    }
+}

phantomreason-0.1.0/deployment/phantom-agent.service.example

@@ -0,0 +1,16 @@
+[Unit]
+Description=PhantomTrace Agent Service
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=/opt/phantom-agent
+Environment=PHANTOM_AGENT_API_TOKEN=replace-with-long-random-token
+ExecStart=/usr/bin/python3 /opt/phantom-agent/serve.py --host 127.0.0.1 --port 8080 --dim 512 --sparsity 47
+Restart=always
+RestartSec=2
+User=phantom
+Group=phantom
+
+[Install]
+WantedBy=multi-user.target

phantomreason-0.1.0/phantomreason/__init__.py

@@ -0,0 +1,20 @@
+from .model import PhantomLanguageModel, run_interactive_test
+from .evaluate import run_evaluation
+from .service import PhantomAgentService, build_server
+from .storage import EXTRA_WORDS_PATH, GLOBAL_INDEX, GLOBAL_VOCAB, MODEL_STATE_PATH, vocabadder
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "EXTRA_WORDS_PATH",
+    "GLOBAL_INDEX",
+    "GLOBAL_VOCAB",
+    "MODEL_STATE_PATH",
+    "PhantomAgentService",
+    "PhantomLanguageModel",
+    "__version__",
+    "build_server",
+    "run_evaluation",
+    "run_interactive_test",
+    "vocabadder",
+]