Skip to content

Releases

vi-mcp 0.67.0

Choose a tag to compare

@imoes imoes released this 16 Nov 09:50

What is new

  • A package for Arch Linux and CachyOS (deploy/arch/build.sh → dist/vi-mcp-<version>-1-any.pkg.tar.zst). Install with
    sudo pacman -U.

    • Dependencies from the official repositories: python, python-numpy, python-scikit-learn, python-cryptography, python-yaml.
    • Optional: clingo (only in the AUR), python-pip (for vi-mcp logic install), python-psycopg, libtorrent-rasterbar.
    • Arch conventions:
      • the code goes to /usr/lib/vi-mcp, not libexec, so a Python update needs no rebuild;
      • users come from sysusers.d;
      • the service is not enabled by the package; the install prints how to start it.
    • Measured in a fresh archlinux:base-devel container (Python 3.14.9, OpenSSL 4.1.0): install, users, directories with the same
      owners and modes as Debian, configuration, an instance, and the server answering /health with "ok vi-mcp"; removal keeps data
      and configuration.
    • Found while testing: pacman runs a package's post_install before the sysusers hook at the end of the transaction, so the
      install creates its users itself first. A partial upgrade (pacman -Sy without -u) breaks python-cryptography (libssl.so.4);
      the README therefore says pacman -Syu.
    • Not yet: deploy/release.sh and the signed package repository do not build or publish it. CachyOS itself was not tested — it is
      Arch-based and uses pacman and the same repositories.
  • vi_recall collects by itself when a question wants everything about one entity. The user said (16.11.2026): "Bei einer Recherche können
    auch mehr als vier Werte von einem Objekt relevant sein. Z.B. welche Ausstattung hat ein Host." On the production copy, 20 % of all
    objects are parts of longer pages (9,196 parts of 3,387 pages, up to 159 parts), and the facts about one host are spread over several
    pages; ranked hits return only a fraction of such a set (QUEST 2305.11694, QAMPARI 2205.12665).

    • When: the question names an entity that exists as a host: hashtag value and asks to collect ("what equipment", "all",
      "overview", …) or is little more than the name. Single-fact questions about the host ("backup failed on X since yesterday") stay
      ordinary searches. collect=false switches it off, e.g. for an A/B measurement.
    • What: the hits plus every visible object carrying the entity hashtag. Page parts are joined by data.source in their order and
      chunked by the new chunking (structure-aware, heading path in front, ported from IT-AIKB). context_budget (also from IT-AIKB, where
      ~10k selected tokens answered as well as the full context in 53 s instead of 137 s) chooses chunks under a budget of 1,500–8,000
      tokens, with chunks naming the entity first. The output is in page order with […] for gaps, plus one line on why the mode switched
      on and what was left out with its reason.
    • Measured on a production copy (the hardware question about one production host): the host's own knowledge page first (CPU model, cores, RAM,
      OS, addresses, purpose, services), 13 of 17 pages in 7,971 tokens; 10.9 s instead of 2.8 s, most of it the reranker over ~170 chunks.
      The router was right on 4 of 4 probe questions. A completeness measurement with a multi-target question set is still open (below).
    • Fixed on the way, also present in the IT-AIKB original: a table that is only an oversized header row lost all its text when
      split. On the copy: 21,580 contents → 93,515 chunks, none losing text, none over the limit.
    • VIL domain lexicon (lexicon.py). The user asked that VIL take in more words, since it is meant to be a technical language. The
      entity words of the memory's hashtags are linked in free text and named in the search note (entities: …), never reordering hits:
      hosts, sites, monitored services, applications, projects, areas, networks, error keys.
      • Production copy: 967 hosts, 74 sites, 356 services, 75 apps, 49 areas, 2 networks, 60 error keys; 58 file paths tagged as host
        and 8 error keys shorter than an everyday word are left out and counted. Built in 0.11 s, linked in 0–36 ms per question.
      • A name counts only if the asking instance can see an object carrying it, so the note never reveals a private or internal name.
      • The collect mode triggers for hosts, sites, services, apps and projects. Its word lists are English: VIL is the memory's
        standard language, and an agent asks it in English.
    • List questions are answered from the hashtags. "Which hosts are at site X" lists the hosts, apps and services that occur with
      the entity, each with its number of objects. A broad entity (more than 300 objects; a site carries about 1,400, mostly monitoring
      findings) contributes only its 100 objects that match the question, filled up by recency.
    • Follow-up for agentic search. An agent searches on with follow-up questions, so the answer names its next steps: the pages not
      shown (ranked by their best chunk), vi_object for a page in full, the entity filter for all its objects, and a narrower question.
    • Evidence: tests/test_chunking.py, tests/test_context_budget.py, tests/test_collect.py (11 cases incl. visibility of names).
  • Fine-tuning paper: eighteen runs that teach a 0.6B model to work by the seed (docs/FINETUNING_PAPER.md).
    The paper reports each run's design, the results scored by the solver, the findings with sources (33 references, each checked
    against the paper text or its arXiv entry), the status against the targets, the measurement errors corrected on the way, and the
    open points.

    • Measured: answering with facts first raised exact verdicts from 18/40 to 29/40 (p = 0.013), and an enumerated count trace raised
      them to 39/40 and 154/160.
    • The seed as a training target made recitation exact (46/46).
    • With held-out phrasings, only 3/40 worlds are judged right: reading is the open problem.
    • PAPER.md section 6.5 links to it.
  • kollektiv 1.3.0: origins count, not votes — the collective's answer to fake news. The user asked on 15.11.2026: "Nur weil 1000
    Menschen etwas glauben, muss es nicht wahr sein … Eine KI arbeitet nur theoretisch und kann Fakten nicht überprüfen." The seed now
    says how well a statement is supported, never that it is true; the spoken verdict reads "supported/opposed", no longer
    "true/false". Five new principles, each a block of the seed:

    • P8, origins, not votes. derives_from(O, R): a copy, re-post or summary adds no origin, and a chain of copies leads back to
      one root. machine_made(O): text a model generated is never an origin; it counts only through the source it derives from. A
      citation circle has no root and counts for nothing. Background: Condorcet's jury theorem needs independent judgments;
      informational cascades (Bikhchandani, Hirshleifer, Welch 1992); model collapse (Shumailov et al., Nature 2024).
    • P9, weight of evidence. evidence_kind(R, measured|signed|document|hearsay): hearsay alone can neither accept nor reject.
    • P10, bridging. camp(R, C): when the camps are known, acceptance needs agreement across camps (Community Notes, Wojcik et al.
      2022).
    • P11, testability. A statement that no observation could refute gets its own acceptance value untestable, neither accepted nor
      rejected. An accepted statement without a named refuting observation (testable_by) obliges the member to name one (Popper).
    • P12, extraordinary claims need more. extraordinary(S) needs three independent origins or a measurement (Hume).
    • P13, a withdrawal is not a refutation. withdrawn(S): when the author withdraws a statement and no one else has given
      evidence, the statement gets the acceptance value withdrawn, never rejected. Withdrawing removes the claim; it does not prove
      the opposite (Codex, round 1). The shadow comparison found this: 16 of 17 objects refuted on production were refuted only by
      their own author. The memory now names the two apart as well (see "What has changed").
    • P10 names a partly known camp camp_unknown, not one_camp, so missing camp data is never reported as one-sidedness.

    Every holding back names its reason: grund(S, held_back, hearsay_only|one_camp|extraordinary). Inputs that are absent change
    nothing, so every world of 1.2.0 keeps its verdict.
    Evidence:

    • vi-mcp philosophy check kollektiv: 35 of 35 worlds (19 new, with counterfactuals), every value and acceptance produced;
    • 1,500 random worlds all solve, with at most one value and one acceptance per statement;
    • tests/test_philosophy.py::test_kollektiv_counts_origins_not_votes_and_names_why_it_holds_back. Package hash 1f205f4c… (1.2.0
      was fdfd38e8…).
  • A provenance adapter fills kollektiv 1.3.0's inputs from the memory. Shadow mode only: it changes nothing.
    vi_mcp/philosophy_provenance.py turns what is stored about a knowledge object into seed facts. The mapping is documented
    input by input in the module.

    • author; one line per stored confirmation or refutation entry. The origin is the cited source (one source is ONE origin however
      many confirm it), a named object, or the confirmer's own check.
    • closed only when the object's counters equal the entries kept. confirm/refute keep 100 entries but count every call; dropped
      entries are neither invented nor ignored.
    • camp = the model family, for every origin that has one. The seed judges a partly known camp (P10 camp_unknown); one place
      decides.
    • withdrawn(S) when the author's own refutation entry exists (P13): a withdrawal removes the claim, it does not prove the opposite.
      Shadow reads memory's new mode zurueckgezogen as the class withdrawn; an unmigrated widerlegt is still split into
      refuted_by_author and refuted.
    • derives_from along objects whose source names another object; machine_made for the automatic server instance witho...
Read more

vi-mcp 0.66.1

Choose a tag to compare

@imoes imoes released this 15 Nov 15:07

What was fixed

  • Two example values in the code resembled real credentials. A comment in vi_mcp/anonymize.py and a test in
    tests/test_anonym.py used them as examples of a password shape. They had been public since 0.13.0 (08.11.2026).
    • Both are replaced by invented values of the same shape, and the tests check the same detection.
    • The whole git history was rewritten (git filter-repo; every commit hash changed), and every tag was moved to the rewritten
      commit.
    • The packages of every earlier release were removed from GitHub Releases and from the apt/dnf repository, because they were built
      from the old tree. This release is the first clean one.
    • Code is otherwise identical to 0.66.0.
      Evidence: a fresh clone of the repository, every reachable blob searched, 0 hits; 217 old release assets deleted, 0 left.

Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.

vi-mcp 0.66.0

Choose a tag to compare

@imoes imoes released this 15 Nov 12:14

What was measured and changed in the search

  • Hit@4 is measured. The answers show 4 results, and the nightly figures now include hit4.
  • Baseline on a production copy, 150 questions × 2 styles = 300 queries:
    • hybrid: Hit@1 0.80, Hit@4 0.933 (natural questions 0.90, keywords 0.967), MRR 0.864, median 2.5 s;
    • full text: Hit@4 0.56.
  • Time per hybrid query: the reranker 1,868 ms of 2,366 ms; embedding 65 ms; candidates 87 ms.
  • Scale test with 500,310 knowledge objects: the copy plus distractors copied from source pages without evaluation targets,
    vectors with noise. This is a proxy for future data, not a picture of it.
    • Hit@4 holds: 0.930.
    • The median time grew from 2.4 s to 6.4 s, mostly from full text: two calls per query, 1.74 s each.
  • Fixes on the branch. None of them changes a ranking: 300 of 300 ranks are identical, and a test checks it.
    • The vector matrix is kept between queries. It is invalidated by writes and by the table's signature.
    • Full text matches first, and visibility is filtered on its hits only. The exact query runs when invisible rows fill the pool.
      Measured on the 500k copy: 1,826 ms → 80 + 10 ms.
    • A hybrid query no longer runs a second, unused full-text search.
    • The vector count comes from the cache.
      Evidence: tests/test_search_scale.py.
  • Tested and not adopted: the object's content in its single vector. An A/B test on a 5,000-object universe from the
    production copy used the same 300 queries and the same code; only the vectors differed.
    • A, key statement only (as today): Hit@1 0.88, Hit@4 0.963, MRR 0.923.
    • B, key statement plus the first 3,600 characters of content in one vector: Hit@1 0.77, Hit@4 0.843, MRR 0.807.
      Natural questions fell from 0.94 to 0.747.
    • 45 queries ranked worse and 13 better. One long vector per object dilutes the key statement.
    • Next to test instead: content in chunks, each with its heading path, as it-aikb indexes it.
      Evidence: measure.py on two copies (vi_subA.db and vi_subB.db), 15.11.2026.

What is new

  • The kit scores a trained model's prose by the round trip: phil_roundtrip.py. It is a separate script, not a phil_score
    option: phil_score stays offline, fast and deterministic, while the round trip needs an endpoint and minutes.

    • For each explain (whole and per block) and recite answer of the tuned model and of the base model, an OpenAI-compatible
      back-translator (--judge-url/--judge-model, preferably another model family) writes clingo-object, with up to 4 repair rounds.
      It uses clingo_object/philosophy_explain.py, which is bundled with the kit.
    • Reported per answer: agreement of the rebuilt seed with the seed's answers AND duties on the package worlds plus --random N
      worlds, the repair rounds, and whether it ran at all (a seed that does not run agrees with nothing and gets a named reason).
    • A control stands beside every number: --control FILE (the frozen historical prose tests/fixtures/kollektiv_principles_1.1.0.json
      or plain text), else the items' gold_text of a 1.1.0 kit. It is back-translated by the same model.
    • A blind reading aid eval/philosophy_blind.md pairs each explain answer with the seed's rules in a random order, with the key in
      eval/philosophy_blind_key.json.
    • Answers and control are resumable (eval/philosophy_roundtrip.jsonl); the summary is eval/philosophy_roundtrip.json.
    • The back-translator can be a command instead of an endpoint: --judge-cmd "codex exec -s read-only --skip-git-repo-check"
      (decision 15.11.2026: Codex as the back-translator, because its GPT family is independent of the trained Qwen, and Claude wrote the
      seed). The same option exists for vi-mcp philosophy explain.
      • Every call runs in a fresh empty directory with stdin closed. The prompt is the flattened messages, last on the command line,
        opening with "Do not run any commands and do not read any files". The reply is read from the -o file, code fences stripped.
      • A template with {prompt} {out} {dir} {model} serves any other command-line model.
      • back_translator records argv[0] plus the model.
      • A failing command stops the run with its exit code: a broken judge is never scored as the model's failure.
      • The MCP tool never runs a command a caller names; it is offered on the command line only.
      • Tests use a fake command, never the real codex.
    • It reads this kit's layout and run 6's (eval/eval.jsonl, eval/answers.jsonl, no philosophy/: --package kollektiv; the
      1.1.0 → 1.2.0 hash difference is recorded as hash_mismatch; the translated seed is identical).
    • Tests (tests/test_finetune.py, a fake OpenAI server, no real endpoint): faithful prose agrees on every world, unusable prose is
      reported as not run after 4 rounds, the control, the blind file without model names, resumption without new calls, and the run-6
      layout.
  • One kit for the whole seed path: language → seed → GRPO, with its evaluation. The user decided the order on 15.11.2026:
    "first teach the AI clingo, then the seed". vi-mcp finetune kit DIR --base M --philosophy NAME now writes everything, without
    hand-made data:

    • --stage language: clingo-object in both directions, on rule sets that share no predicate with the package (3,000 rows).
    • --stage philosophy: the seed's judge, formalize and pressure examples (1,700 rows). Half of the judge and pressure prompts show
      the seed's rules first. The test split uses held-out phrasings and pressure, and none of its worlds occurs in training.
    • --stage grpo (the seed as reward) now continues out/philosophy by default.
    • language and philosophy are new SFT stages, not logic: the kit's logic files are vi_logic episodes from the VI, and the
      seed path needs its own adapters and lineage.
    • No principle prose and no seed comment line enters any training row (test). Only the clingo seed is stored, and prose is a
      translation of it.
    • eval/philosophy.jsonl: judge on training phrasings and on held-out phrasings, held-out pressure, held-out formalize, the
      package worlds, explain the seed (whole and per block), recite, and the held-out language. A judge item whose world occurs in
      training is dropped and counted.
    • phil_answers.py writes base and tuned answers, resumable, with a named generation budget. phil_score.py scores them against
      the seed's verdict: world_exact, every answer value, duties_exact, invented certainty, facts_exact, budget cuts.
    • A package without training data (generator, wording, pressure) is refused, with the missing fields named.
  • Verdicts are 3–4× faster, with identical results. The seed is translated once per process, and each world is solved once
    (philosophy.solve); before, every verdict translated and solved twice. Measured 15.11.2026 on the workstation, with gold
    fingerprints unchanged:

    • messung: pool of 200 prompts 15.9 → 4.3 s, re-solve 10.9 → 3.1 ms per prompt;
    • kollektiv: 3.3 → 1.0 s and 6.8 → 2.0 ms.
      The GRPO seed check before training uses the same single solve.

    Evidence:

    • tests/test_finetune.py::test_one_kit_holds_the_whole_seed_path_without_any_principle_prose: the kit's own phil_score.py
      on simulated answers gives the seed's words every world exact and nonsense none.
    • tests/test_philosophy.py::test_one_solve_with_the_translated_seed_gives_exactly_what_the_full_check_gives.
    • tests/test_training_runtime_neural.py -k seed_path: real SFT trainers, 0 optimizer steps.
  • Philosophy packages store only the clingo seed; prose is a translation, checked by its round trip. User decision
    (15.11.2026, confirmed twice): "Wir hatten gesagt, dass wir nur clingo speichern und diese dann in Prosa übersetzt werden …
    Deswegen trainierst du die VI auf clingo-object." Scope: philosophy packages only; normal knowledge storage is unchanged.

    • Format philosophy-v2 (clingo_object/philosophy.py): the seed is the single stored source. principles is no longer a field.
      A package that still stores it, or says philosophy-v1, is refused with the reason.
    • The seed's rules stand in blocks marked by an id comment (# P1) and nothing else. A title is not allowed: any word next to the
      rules is meaning outside them, and a translator would copy it instead of reading the rules.
    • check now requires every rule to lie in a marked block, with no other comment, no rule before the first marker and no marker
      twice. This replaces "every derived predicate is named by a principle"; every other check stays.
    • The priority profile maximal-candidates-v1 lost its prose too. Its rules are now pinned as the translated program; that hash
      (b2e98f6f…) is the same before and after.
    • Packages: kollektiv 1.2.0, messung 1.1.0 and code 1.1.0 keep their seeds, vocabularies, worlds and training specs.
      • The translated ASP of all three seeds is byte-identical before and after (sha256 of notation.translate(seed)), so every verdict
        is unchanged.
      • The package hashes change: kollektiv 8d213463… → fdfd38e8…, messung 8ed31063… → b1277f8e…, code 6f795887… →
        09d6da84…. Once the new version is installed, a binding to the old hash shows stale until it is bound again; the old
        installed object keeps its v1 manifest and still matches its hash.
      • Training run 6 uses frozen data and is unaffected.
      • kollektiv's old prose is frozen in tests/fixtures/kollektiv_principles_1.1.0.json as the historical prose of 1.1.0. It is the
        gold reference of a running evaluation and is never loaded as a source.
    • New vi-mcp philosophy explain NAME --url U --model M --judge-url U2 --judge-model M2 (tool vi_philosophy action explain,
      clingo_object/philosophy_explain.py):
      • A translator writes English prose per block and for the whole seed.
      • An indepen...
Read more

vi-mcp 0.65.0

Choose a tag to compare

@imoes imoes released this 15 Nov 08:50

What was fixed

  • The training export no longer teaches a model to echo documents. Knowledge without a real (doc2query) question was exported
    as "question = the object's own text, answer = the object". In the first production run that was 96 % of the SFT rows (20,066
    of 20,957). The blind test of the tuned Qwen3-0.6B (100 questions, judged pointwise against references, key opened afterwards)
    showed:

    • no gain on the 60 real questions (base 0, tuned 0 correct);
    • a gain only on rows of the same echo form;
    • loops in 55 % of the tuned answers (base 1 %);
    • invented page paths instead of "I don't know".

    Such knowledge now goes to documents.jsonl and is never trained as its own question; qa.jsonl holds real questions only.
    Hint ratings (KTO/DPO) still use every rated object.
    Evidence: tests/test_dataset.py::test_export_writes_qa_kto_dpo_with_datasheet_and_holds_out_the_evaluation.

What is new

  • Knowledge becomes training-ready after it is learned, without a later synthesis step. While it sleeps (step 8i, classify.pairs_per_sleep, default 5) or on
    vi-mcp classify --pairs [--limit N] [--workers W] [--stale], the server writes onto each shared or internal knowledge object
    data.qa. It holds grounded question-answer pairs, one never-trained probe question, rejections per reason, the hash of the text
    the pairs came from, and the generator version. --dry-run counts the objects per state. Before this, every run had to
    synthesize pairs for all documents on the trainer: about 25 h for 23,585 documents with a 35B model.

    • The export trains the pairs (question_source: synthetic) and writes the probes to probe.jsonl.
    • Pairs of knowledge that changed since are named stale and left out (manifest.quality.stored_pairs).
    • A failed generation is retried after a day.
    • Private knowledge is never sent.
    • Server and kit share one definition of a good pair (vi_mcp/qa_pairs.py, copied into the kit).
      Evidence: tests/test_finetune.py::test_server_stores_training_pairs_with_a_probe_and_the_export_uses_them.
  • The knowledge probe is part of the kit. split/probe.jsonl holds the probes of objects whose rows are on the train side.
    probe.py answer|judge|summarize does what run 3 did by hand:

    • base and base+adapter answer from the same weights, written per question, with the A/B key in a separate file;
    • an OpenAI-compatible judge, or a person, grades each answer correct, partial or wrong;
    • summarize unblinds and runs the sign-flip test, strict and lenient, into probe/probe_eval.json;
    • an answer cut at the generation budget counts at most partial;
    • a judge that also wrote the probes is flagged (self-preference).

    synth_qa.py writes one probe per document as well. vi-mcp finetune record records the probe result; it is not the adoption gate.
    Evidence: tests/test_finetune.py::test_documents_without_a_question_become_grounded_synthetic_pairs_never_echo_rows.

  • docs/FINETUNING.md: fine-tuning from zero. It covers the data fields, turning on pair generation, the
    kit, the container, training with the recipe that worked, the probe, recording, and the limits. It ends with ranked next
    improvements from research of 15.11.2026: retrieval plus a fine-tuned reader (RAFT), abstention training, more exposures per
    fact, QA before documents, short canonical answers, rank against forgetting, and cleaner probes. The handbook
    (vi_finetune guide, version 2026-11-15) and AGENTS.md follow the same steps.

  • synth_qa.py in the fine-tuning kit turns documents.jsonl into question-answer pairs with an instruction model over an
    OpenAI-compatible API (thinking off, no token cap). It keeps only grounded pairs: at least 80 % of the answer's words occur in the
    document, the question names its subject instead of "the document", and nothing is copied from the document's beginning.
    Rejections are counted per reason; the script is resumable. vi-mcp finetune split DIR puts the pairs into the shared split, and
    run.json records the question sources per side. Diverse QA pairs inject knowledge better than raw text (arXiv 2409.07431,
    2412.14964). Measured: 12 real documents → 14 pairs in 38 s, 21 candidates rejected.
    Evidence: tests/test_finetune.py::test_documents_without_a_question_become_grounded_synthetic_pairs_never_echo_rows.

  • More varied pairs per fact, and a held-out guard. synth_qa.py --pairs N asks for up to N pairs per document; --more FILE
    asks chosen documents again (duplicates are rejected); --hold-out FILE rejects a pair whose question is too close (word Jaccard
    ≥ 0.5) to a held-out evaluation question of that document. Knowledge recall rises with the number of paraphrases per fact
    (arXiv 2312.05934, 2411.00686). train.py --lora-rank R sets the adapter rank (alpha 2R; default 16 as before).
    Evidence: tests/test_finetune.py::test_documents_without_a_question_become_grounded_synthetic_pairs_never_echo_rows.

What was reviewed

  • Codex reviewed 0.65.0 before release. It answered through the VI (frage:2b8276601a6c8b429ee5e54c), read-only, with
    reproductions; everything it reproduced is fixed:

    • A pair result is written onto the CURRENT object, and only if its text is unchanged and it is still shared, internal and live.
      Before, the copy loaded before the minutes-long model call was saved whole, which could undo a refutation or a switch to private.
    • The source line is scrubbed like the answer. A credential the scrubber removed came back through the raw source of pairs,
      probes and documents.
    • No training question may come close to its object's probe (word Jaccard ≥ 0.5), whatever made it: doc2query, stored pairs,
      synth_qa.py or agentic rows. This is checked in the export and in the split.
    • probe.py summarize accepts only answers of today's probe file and adapter, every probe judged exactly once. Before, six old
      judgments with no current probe gave decision = true under the current hash.
    • Changed knowledge is renewed in sleep, from a random sample of 200 per sleep, in any state. Pairs of an older schema are never
      exported. The content hash is exact (whitespace is content in code).
    • qa-v3: every number in an answer must occur in the document (port 22 vs 80 passed before), and the question must name the
      document's subject. Long pages are flagged truncated.

    Evidence: tests/test_finetune.py::test_codex_review_findings_on_stored_pairs_are_fixed and
    ::test_grounding_counts_facts_not_function_words. With the real model, qa-v3 kept 23 pairs and 10 probes on 15 of 20 objects.

What was measured

  • Stored pairs with the real model. Qwen3.6-35B-A3B Q4 wrote pairs for 20 of the newest objects of a production copy, through
    vi-mcp classify --pairs --workers 4.

    • The first grounding rule (qa-v1, as in synth_qa.py of runs 2 and 3) kept only 1 of 25 pairs on six short German findings,
      because function words such as "die", "wurde" and "auf" counted as ungrounded, and so did "host" and "dns01" inside
      host:dns01.….
    • qa-v2 counts content words only and matches the parts of compound tokens: 25 pairs and 11 probes on 14 of 20 objects,
      51 pairs rejected.
    • Invented hosts, dates and IPs still fail the check.

    Evidence: tests/test_finetune.py::test_grounding_counts_facts_not_function_words.

  • Second run (corrected data): 3 epochs, LoRA r16, on 894 doc2query plus 2,042 synthesized rows. Loops fell from 55 to 6 of
    100 answers. On questions about held-out documents there is no significant gain (p ≈ 0.1). A test set of held-out documents
    cannot show knowledge injection, because closed-book fine-tuning only knows what it was trained on. On 60 new questions
    about trained documents (a knowledge probe), tuned scored 4 correct and 3 partial vs base 0 and 5 (strict p = 0.0625), so a gain
    is visible but not yet significant. The tuned model never says "I don't know" and invents hosts and IPs.

  • Third run: the first measured knowledge gain.

    • Setup: 500 trained documents with about 5 varied grounded pairs each (--pairs 8), LoRA r64, 4 epochs (2,558 rows, 53 min).
    • Result on the same 60-question knowledge probe: 7 correct and 9 partial vs base 0 and 5.
    • Statistics: one-sided sign-flip test strict p = 0.008, lenient p = 0.006, graded p = 0.001. The adoption gate is passed.
    • The absolute level is still low (12 % correct), and the model does not abstain.
    • Evidence: blind judgments with the key opened afterwards. The base grades were identical in both judging rounds.

What is still missing

  • Synthesized pairs are model output checked for word overlap, not verified by a person.
  • Probe questions come from the same generator as the training pairs, and a word-Jaccard guard misses rephrased duplicates
    (arXiv 2311.04850). A probe set written by people or by another model family is not built yet.
  • The tuned model does not abstain; abstention training is described in docs/FINETUNING.md but not implemented.
  • Grounding is lexical: a reversed negation ("must not" → "can") still passes (reproduced by Codex). An entailment check by a model
    is not built.
  • Long pages get pairs only from their first 6,000 characters (flagged truncated); pairs per anchored chunk are not built.
  • Stored QA questions are not yet indexed for search (full text indexes text, vectors o.text), so they do not help retrieval yet.
  • vi-mcp classify --pairs for the existing production knowledge has to be started once by an operator. Until then, the kit's
    synth_qa.py covers the rest.

Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.

vi-mcp 0.64.1

Choose a tag to compare

@imoes imoes released this 14 Nov 20:03

What is new

  • A fine-tuning runbook in AGENTS.md that an agent can follow end to end: data and kit from a read-only copy, its own GPU
    container, memory on unified-memory hosts, precision, the order of commands, measured cost, a blind judgment of task success,
    and record and merge. It is written from the first complete run on 14.11.2026 (Qwen3-0.6B on an AMD gfx1151 GPU: held-out
    NLL 2.269 → 1.294 after 0.25 epoch in 4.1 h).

  • Opening a shown hint counts again when the hook showed it (statistics loop, 14.11.2026). Production showed "opened with
    vi_object after being shown 0" over 7 days, with 1503 vi_object calls. Claude Code's hook shows hints in its own MCP session
    (client claude-code-hook), and the agent opens them over its own connection. vi_object counted an open only within the same
    session, so this weak signal of use was structurally 0. The same-session check is gone; intuition.opened already links by
    instance and the recent experiences in which the hint was shown. Another instance opening the object still does not count.
    Evidence: tests/test_hint_quality.py::test_opening_a_hint_the_hook_showed_in_another_session_counts (failed before: 0 == 1).

  • A kept legacy router champion gets its own measured AUC (statistics loop after the 0.64.0 deploy, 14.11.2026). Production showed
    "router AUC None": the active champion was trained by 0.63.2 without a saved report. 0.64.0 rightly no longer shows the
    challenger's numbers for it, but showed nothing instead. The incubator's router criterion therefore stayed "not measured" for as
    long as the champion was kept, and every challenger since was worse (log loss 0.292 vs 0.279).

    • compare_champion now also computes the champion's AUC on the same holdout actions it had not seen.
    • A legacy champion keeps that number, with its provenance named.
    • vi_stats names the reason when no AUC is known.

    Evidence: tests/test_training_audit.py::test_a_legacy_champion_gets_its_own_measured_auc_not_none (failed before).

  • heldout_loss.py in the fine-tuning kit measures the held-out next-token loss of the base model and of a LoRA adapter on
    one stage's test split (--stage sft|agentic|logic), with the same tokens and masks as training. It runs on GPU or CPU and also
    with --base-only. Use it to check that the model absorbed the VI's knowledge; it is never the adoption gate, which needs
    independent judgments or executable references. Evidence: tests/test_training_runtime_neural.py::test_heldout_loss_of_a_fresh_adapter_equals_the_base.
    A fresh adapter with B = 0 gives exactly the base loss, so the comparison is like with like.

  • Every training stage with at least 5 groups gets held-out test groups. In the kit built from production on 14.11.2026,
    the logic stage had 14 groups and 0 test rows: the joint 15 % group sample over all stages missed it (about 0.85^14 ≈ 10 %
    of seeds). Its gain could never be measured. Now each such stage gets its share of test groups. Components stay joint across
    stages, so this only adds held-out groups. The split reports groups and test_groups per stage. Evidence:
    tests/test_training_audit.py::test_every_stage_with_enough_groups_gets_held_out_groups. With the old code, seeds 8 and 10 of
    25 gave the logic stage 0 test rows; now all 25 seeds give it test groups.

  • train.py --fp32 in the fine-tuning kit trains in float32 on a GPU, with no bf16/fp16 mixed precision. Before, a GPU that
    reports bf16 support always got bf16. For AMD gfx1151 (Strix Halo), community reports list bf16 problems
    (ROCm/TheRock#9198). The report names the precision. Evidence:
    tests/test_training_runtime_neural.py (tokenizer-only with and without --fp32).

Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.

vi-mcp 0.64.0

Choose a tag to compare

@imoes imoes released this 14 Nov 14:54

What is new

  • Real trainer preflight without training, in every generated fine-tuning kit: tokenizer-only inspection or actual SFT, agentic,
    logic, KTO and DPO trainer construction, collator verification and one no-grad loss. Reports bind dataset/tokenizer/template/config,
    dependency versions, complete-target counts, parent readiness, unchanged parameters and zero optimizer steps. A program-first
    --from-base path needs no preceding QA adapter. New adapters retain the resolved base revision for subsequent stages, which
    refuse an explicit revision mismatch. The tested dependency versions and public solver sources ship with the kit.
    Evidence: tests/test_training_runtime.py, tests/test_training_runtime_neural.py, tests/test_anonym.py;
    setup and scope in docs/TRAINING_PREFLIGHT.md. No fine-tuning was started.

  • Complete virtual instances, vil-instance-v1: persisted context, model/decoder identity, MCP device descriptors, explicit
    permissions and a bounded, resumable client-side execution loop. vi-mcp machine run|checkpoint|boot connects that loop to trusted
    MCP devices; reservations precede calls, uncertain writes never retry automatically, and restoration cannot recover capabilities
    revoked in the current host profile. The controller records VI before/after experience without treating its own completion as a
    verified grade. Evidence: tests/test_instance.py, including real MCP/CLI transport and database reopen after an uncertain write.

  • One coherent symbolic/neural checkpoint captures context, rules, rights, model identity and kNN shards while the datastore
    writer lock spans the symbolic capture. Execution receipts and independent checks survive boot too. Boot verifies the complete
    instance/evidence hash, manifest and current model/capabilities and makes an independent
    writable clone sharing the frozen core. Transport URLs and credentials stay outside the bundle. Evidence: tests/test_instance_neural.py,
    tests/test_knn_lm.py, tests/test_anonym.py. A real configured LLM completed inventory lookup → fact insertion → solver query in
    four model calls; its answer matched the independent synthetic fixture. A frozen neural fixture also generated a remembered complete
    clingo-object program and ran it on two data states without parameter updates. Contract and reproduction: docs/INSTANCE_RUNTIME.md.

  • Independent review handoff in docs/CLAUDE_REVIEW.md: assessment, production-snapshot findings, implementation commit,
    reproducible neural/runtime evidence and the SQLite/PostgreSQL suite results, with the remaining architectural boundaries.

  • Real kNN-LM token inference, vi-mcp knn: frozen Transformers causal models expose hidden context states and next-token logits;
    an atomically mutable datastore supplies squared-L2 neighbors whose token probabilities are mixed with the base distribution.
    Sources can be replaced or withdrawn, snapshots remain independent, generations pin a revision, and model/weight/tokenizer identity
    prevents incompatible keys. An OpenAI-compatible text-program endpoint connects the VI to this backend; execution receipts retain
    its datastore and weight hashes. Evidence: tests/test_knn_lm.py checks the distribution, revision/isolation, corruption refusal,
    authentication and a real transformer. scripts/demo_knn_lm.py ran a pinned pretrained model: replacing a source changed its next
    token from blue to green at unchanged weight hash; probability rose from about 0.002% to 75%. This is a memorized-context mechanism
    test, not a held-out quality gain. See docs/KNN_LM.md for installation, operating limits and the reproducible experiment.

  • VIL and clingo-object have a persistent virtual-machine runtime, vi_machine / vi-mcp machine, contract vil-machine-v1.
    Private machines own mutable objects and rules; explicit instructions define and execute programs, import/refresh visible VI
    objects, record proposals and verify complete reference answers. Immutable snapshots, restore, independent forks, state hashes
    and optimistic revisions make changes reviewable. The server's model can write programs over one frozen machine world; a
    concurrent world change rejects its commit. Model calls do not hold the global database lock. No caller Python, shell or external
    write is executed. Evidence: tests/test_machine.py changes a fact from port 80 to 8080 under the same program, restores after a
    database reopen, forks independently, rejects cross-owner/stale access and checks a model repair against an independent fixture.
    The contract and boundaries are in docs/VIRTUAL_MACHINE.md.

  • Checked machine executions teach program writing. An owner may explicitly publish one reference-checked receipt internally
    (teach). Correct programs become tool-use SFT; incorrect programs and independently replayed failed repair attempts become KTO
    negatives. Correct and incorrect programs under exactly the same question and world become DPO pairs. Private machines and
    snapshots themselves are never selected for export. Evidence: tests/test_machine.py, tests/test_anonym.py.

  • Executable held-out program evaluation in the fine-tuning kit (program_eval.jsonl, program_evaluate.py) compares full
    answers against frozen reference worlds, including missing/extra rows, syntax errors, uncertainty and resource limits. Cached
    model predictions allow offline replay. The normal evaluator now collects predictions and requires independent correctness
    judgments. Adoption requires a report bound to the test file and a positive conservative confidence bound over independent task
    groups. Evidence: tests/test_training_audit.py, tests/test_finetune.py. No fine-tuning run or general capability gain is claimed.

  • Retrieval drafts for the kNN-LM (generate(draft=N), vi-mcp knn generate|serve --draft N). This is exact
    retrieval-based speculative decoding after REST (arXiv 2311.08252) and NEST (arXiv 2405.19325), without NEST's relaxed
    acceptance:

    • The nearest neighbor's stored continuation is the draft, and one forward pass verifies it.
    • A drafted token is kept only if it is the greedy choice, so the text equals plain decoding up to floating-point
      differences between sequence shapes. That was measured (72/72), not guaranteed.
    • The result names the sources of the accepted tokens (spans).

    Measured with draft=8 on Qwen/Qwen3-0.6B (float32, CPU, 8 threads), using paragraphs of this README: 12 stored (prompt =
    first 12 words, the rest remembered) and 6 controls not stored, 32 tokens each.

    Memory weight Stored: tokens per pass Stored: faster Controls: faster Identical to plain decoding
    0.5 6.40 5.75× 3.05× 18 / 18
    0.25 1.61 1.57× 1.79× 18 / 18

    The controls gain too: the memory supplies drafts even for unrelated prompts. Wall times are in the scratch measurement; in
    float32, plain decoding is about 3× slower than in bfloat16 (87.8 s vs 29.9 s for the same 12 runs).

    Evidence: tests/test_knn_lm.py::test_retrieval_drafts_keep_the_greedy_text_and_save_forward_passes; docs/KNN_LM.md.

  • vi_stats names the reason for a low project success rate (statistics loop, 14.11.2026). Production showed a project
    at 40 % success. A read-only query of the production database found that 184 of its 227 failures were one LLM-provider error
    (Model … does not support the requested features: tools, max_tokens). They all fell between 15:00 and 16:00 UTC on 13.11.,
    and none occurred after the 0.63.3 retry fix. The rate described a past burst, and the line did not say so. Now a project
    below 80 % with at least 10 failures gets a line with its most frequent error class, count and time span, marked "one burst
    within an hour" when it is one. Evidence: tests/test_statistik.py::test_a_low_project_rate_names_its_dominant_error_class_and_span
    (failed before).

  • KTO and DPO now train inside the chat template (Claude's review, item 5; Codex agreed over the VI). Before, preference
    rows were plain strings, and TRL applies no chat template to strings, so preference learning saw a format the chat model never
    sees at inference. training_runtime.prepare now renders the prompt with the model's template (generation prompt, thinking
    off) before the token audit, as the SFT stages do. A doubled BOS is refused (double_bos), and the audit names
    preference_format. The export stays model-independent. Evidence:
    tests/test_training_runtime.py::test_preference_prompts_are_rendered_in_the_chat_template_like_sft. The neural trainer tests
    (real TRL 1.18, trainer tokens checked against the audit) pass: 16 passed.

  • Three more points from Codex's review over the VI (14.11.2026):

    • Interrupted erase. forget marks a tombstone erased before its files are gone, so a crash in between left the data on disk.
      compact now also removes orphan shard files (orphans_removed). Test:
      test_an_interrupted_erase_is_completed_by_compact.
    • Hold-out by live provenance. Machine examples were held out by the live source of their imported objects; a later source
      change let one into training. The source group is now frozen at import as a hash (source_group_sha256). An imported object
      without the frozen value is held out as machine_unknown_provenance, even if it is still loadable, because its live
      source may have changed since. Tests: test_holdout_uses_the_provenance_frozen_at_import, which failed before, and
      test_an_example_imported_without_frozen_provenance_is_held_out.
    • Stated assumptions. The sign-flip gate needs independent groups and, under the null, exchangeable base/tuned outcomes within
      a group; the method text and the kit guide now say so. The red-team "followed" is a proxy (a fixed pattern per attack): it
      misses paraphrased compliance and counts coincidental matches.
  • **...

Read more

vi-mcp 0.63.2

Choose a tag to compare

@imoes imoes released this 14 Nov 08:18

What is new

  • Questions answered in plain language are kept with their program (vi_logic action=answer, table logik_frage), and the answer
    says how to rate one of its conclusions. Once rated, the question and program become training data: rated right an example in
    logic.jsonl, rated wrong a negative in kto.jsonl (the model's own mistake). The user (14.11.2026): no fine-tuning run yet — first
    collect more training data from real use; later the qwen27b model learns, so before and after compare directly. Test:
    tests/test_logic_propose.py (1 new).

What was fixed

  • vi-mcp release on Windows printed a UnicodeDecodeError traceback while restarting the service (reported from a Windows
    installation, 14.11.2026; the release itself went through). schtasks writes in the console's OEM code page (0x81 = "ü" in cp850),
    Python ran with -X utf8. Output of console programs is now read with the OEM code page on Windows and never fails on a byte
    (config.CONSOLE_TEXT; setup, embedding service, network service CLI; git output as UTF-8 with replacement). Test:
    tests/test_release_cli.py (1 new).

Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.

vi-mcp 0.63.1

Choose a tag to compare

@imoes imoes released this 14 Nov 08:03

What is new

  • clingo-object is documented: a section in README.md and README.de.md (asking in plain language, writing rules, the Python
    classes, the agent, the measurements — the Python example was run against a throw-away memory and gives the documented result), and
    section 5.6 of docs/PAPER.md (objects as facts, proposals, one language in two places, measured against SQL, the agent against searches
    alone, training), with its limits, sources and measurements.

What has changed

  • A rating already on the network is published again only when it says something new: its success estimate moved by at least
    0.02, its observations grew by at least 20 %, or it was confirmed or refuted. Measured on production (14.11.2026, open network):
    51 of 87 daily repeats changed neither — entries every peer stores for good (the logbook is append-only). Before: every changed
    value once a day, up to 1,000 a day. Test: tests/test_net_score.py (1 new).

What was fixed

  • clingo_object.Memory and python3 -m clingo_object.agent did not find the VI on Linux. Found on the first live test against
    production (14.11.2026):
    vi-mcp setup writes URL and token file into the hook command in ~/.claude/settings.json there, not into
    hook.json (that is the Windows way), so the client fell back to 127.0.0.1 and was refused. It now reads that hook command too
    (after the environment and hook.json). Verified on the workstation: the server and the token file are found without any variable.
    Test: tests/test_clingo_object.py (1 new).

Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.

vi-mcp 0.63.0

Choose a tag to compare

@imoes imoes released this 14 Nov 07:39

The user (13.11.2026): "Derzeit legen wir Daten per SQL in Objekten ab. Also müssen wir mit diesen Objekten in clingo programmieren" — "wir
machen aus clingo eine objektorientierte Programmiersprache", like Delphi grew out of Pascal; and "clingo ist die Sprache für LLMs". On the
first draft (class blocks inside the server's parser): consistent with the clingo Python package, developed further in Python.

What is new

  • Memory objects in the logic. (O in objects("art:skill host:web*")) binds O to the objects of a vi_recall filter, as the asking
    instance may see them; (O.host == H) reads a hashtag, (O.kind == "skill") a field, (O.age > 90) a number (age, importance,
    confirmed, refuted, accesses); linked(O, B) follows an edge (objects one edge away come along). Never quarantine or archive; what is
    cut (more than 20,000 objects), not visible or excluded is counted and shown; edges are loaded only for a program that follows them. Tests: tests/test_logic_objects.py (28).
  • Rules may propose changes, a person decides. A head propose(tag(O, "status", "stale")) or propose(link(A, B, "reason"));
    vi_logic action=propose derives the proposals on the server and holds each in quarantine (kind vorschlag) with the rules behind it.
    Its author cannot release it; vi-mcp release re-checks and applies it with the proposal's id in the target's change log; discarding
    leaves a tombstone; the same proposal again is counted. System tags, invisible and vanished targets are refused with a reason.
    Tests: tests/test_logic_propose.py (6).
  • The Python package clingo-object (import clingo_object, wheel clingo-object in the release, also shipped in deb/rpm/MSI):
    real Python classes — class Skill(Knowledge): kind = "skill" with methods like def stale(self): return (self.mode == "test") & (self.age > 30), inheritance and overriding by Python's MRO — and expressions by operator overloading compile to the notation the
    server runs; Program.check(memory) solves the same text locally with the clingo API, check_on_server, save, propose, rate send
    it. clingo_object.Memory finds server and token like the hook. Verified: local and server answers agree on the same objects (also
    through a real server on a random port); the wheel installs offline with pip --no-deps and imports without vi-mcp. Tests:
    tests/test_clingo_object.py (15).
  • vi_logic action=objects returns the objects of filters as JSON (the package's data path).
  • Questions in natural language, answered with clingo-object on the server: vi_logic action=answer question="Which DMZ hosts are never described as production?" — the server's language model (the classify model) writes the program, the server solves it with
    the asking instance's objects and feeds refusals back (the agent of clingo_object.agent, with the vocabulary the asker may see). Only
    the notation runs, never Python. The rules every client receives now say: a question over many objects goes to this action. Test:
    tests/test_logic_propose.py (1 new).
  • Verified on both databases: the whole suite on SQLite (910 passed) and on PostgreSQL 16 (911 passed, 3 skipped), 13.11.2026.
  • An agent that answers in clingo-object (clingo_object.agent.solve(question, memory, llm)): the language model writes a program
    whose answer is ans(…); it is solved with the caller's objects; a refusal of the notation, an empty answer or a violated constraint goes
    back to the model in the solver's words, up to 4 rounds (the construct-and-check loop of ALM–ASP, KR 2026, and ASP-Bench, arXiv
    2602.01171). Any OpenAI-compatible endpoint (VI_LLM_URL, VI_LLM_MODEL), never with max_tokens. Tests with a scripted model: it
    corrects a missing parenthesis and a wrong hashtag kind and answers in round 3; says "empty" when nothing derives; sends no
    max_tokens (tests/test_clingo_object.py). From the command line: python3 -m clingo_object.agent "question" — server and token
    like the hook, the memory's vocabulary (hashtag kinds with their most used values) fetched from vi_vocabulary and given to the model.
  • Training with clingo-object. vi-mcp dataset export writes logic.jsonl: for every saved rule set that is not private, the task of
    its description → the assistant writes the program (vi_logic check with the source) → the solver's real answer → the answer citing the
    rule set; and every conclusion someone checked against reality (rate, now kept one by one in logik_bewertung): right ones as
    examples, wrong ones as KTO negatives in kto.jsonl. finetune kit: train.py --stage logic. Programs run as a viewer that sees
    shared and internal objects, never private ones. Test: tests/test_logic_propose.py (1 new).
  • Rules learned from rated conclusions. vi_logic action=learn rule_set=NAME: from the conclusions people rated for that rule set
    (oldest 80 % to learn, newest 20 % held out and reported), clingo itself — as an optimiser over a small hypothesis space of up to two
    field/hashtag conditions the right examples share — picks the rules that cover the most right and fewest wrong conclusions
    (clingo_object/learn.py). Each learned rule is a soft(…) proposal in quarantine with its coverage; released, it becomes a new
    version of the rule set. ILASP was not used: free for non-commercial use only (https://ilasp.com/download). Test: a rule set that
    derived review(O) for every test object, rated right only in the DMZ, learns (O.zone == "dmz") — held out: 1/1 right, 0/1 wrong
    covered (tests/test_logic_propose.py).

What was measured

  • clingo-object answers relational questions exactly as SQL does. On a copy of production (13.11.2026; 24,449 insights, 499,234
    edges), 13 questions over memory objects — e.g. "DMZ hosts never said to be production", "locations of DMZ hosts", "log-monitoring
    findings for hosts at KAS-0", "skills linked to an insight about an error", a never check — each compared with a hand-written SQL
    query: 13 of 13 equal once the object limit was 20,000 (the one difference first seen was an error of the SQL: it counted a refuted
    skill, which searches leave out). At the former limit of 2,000, 3 of 13 answers were incomplete — the cut was reported, but the answer
    was short; hence the new limit. Time per question 0.01–0.6 s, 2.3 s for 13,088 Confluence pages.

  • The clingo-object agent with a real language model (qwen3.8-flash on the central server, temperature 0, one run each), the same
    production copy, natural-language questions, answers compared with SQL:

    step tuned set (12) held out (4) precision recall rounds time
    first prompt 7/12 exact — 0.74 0.75 2.2 10.4 s
    + "join facts about a host through the hashtag value, not linked" 9/12 3/4 0.75 0.75 2.1 6.7 s
    + the notation refuses an object used as a hashtag value 11/12 4/4 1.00 0.99 1.7 5.2 s

    The held-out questions were written after the prompt was changed and never used to tune it. The last step is a rule of the language,
    not of the prompt: the solver's refusal taught the model the right form in round 2 of both questions that had failed. Small sample
    (16 questions, one run) — a trend, not a proof.

    Compared with answering through vi_recall alone (the same model, the same 16 questions, up to 4 searches of up to 50 hits, then an
    answer): 2/16 exact (the two questions whose answer is empty), precision 0.50, recall 0.30, 20.1 s per question — against 15/16,
    1.00, 0.99 and 5.2 s with clingo-object. Where an answer has hundreds of rows (403 findings, 313 pages), a search that shows 50 hits
    cannot be complete; a program over the objects is.

What has changed

  • The language core moved from vi_mcp/logic.py into clingo_object/notation.py; the server imports it — one implementation for both.
  • The server's notation refuses class/def with a pointer to the package: the server runs no Python from callers.
  • A weakness in the VI's self model says when it happened ("tool:analyse … (184×, 2026-11-13 15:02–15:58 UTC)"). Found on
    production (13.11.2026):
    the line "(184×)" read like an ongoing failure — counted per hour, all 184 errors had come in one hour that
    was over, and the analysis reported to CentralStation had to be corrected. Test: tests/test_selbst_schlaf.py (1 new).
  • The search kind says whether the reranker ran (hybrid+rerank beside hybrid, in the usage statistics and the search log), and
    the language model's relevance grades (UMBRELA) are reported per kind. Found on production (13.11.2026): the line "nothing
    relevant in the top 10: 35 %" mixed 20 searches graded from before the reranker was switched on with about 12 after — it could not
    show what the reranker changed. Test: tests/test_relevance.py (1 new).
  • The Debian package recommends python3-clingo; release.sh refuses when clingo_object.__version__ differs from vi-mcp's.

What was fixed

  • An object compared with a hashtag value found nothing, silently. (H in objects("netz:dmz")) & (P.host == H) compares a host name
    with an object id; the notation now refuses it and says how to read the value first. Found measuring the agent. Test:
    tests/test_logic_objects.py (1 new).
  • A check said "follows (200)" when 403 conclusions held. The result keeps the first 200 and now states the total ("follows (403,
    the first 200 kept in the result)"); found during the measurement above. Test: tests/test_logic.py (1 new).

What is missing

  • Learning covers unary conclusions over objects (p("object id")) with up to two conditions; more needs more rated examples first.
    logic.jsonl and learning stay small until rule sets are saved and conclusions rated.
  • The relational task set on a production copy (clingo-object against hand-checked SQL) is not measured yet.
  • Local solving u...
Read more

vi-mcp 0.62.5

Choose a tag to compare

@imoes imoes released this 13 Nov 15:56

What has changed

  • The LLM weight layer ends a test that shows nothing, and proposes at most once a week. Before, an online test that stayed within
    2 standard errors ran forever, and a rejected layer was followed by a new proposal every day. Measured: online +0.0 ± 1.4 points
    (146 vs 674 actions, production, 13.11.2026); CentralStation's twin layer was offline worse in all 33 runs. Research the same day:
    language models are weak numerical optimizers, especially below 70B parameters and for continuous, high-dimensional calibration with
    a small evaluation budget (OPRO, https://arxiv.org/abs/2309.03409; Revisiting OPRO, https://arxiv.org/abs/2405.10276). Now a layer is
    retired with "no effect" after 1,000 actions per arm when the difference is under 1 point and within 2 SE, and a new proposal comes at
    most every 7 days; the layer stays limited to new hints (cold start) and audit findings, where the fit has nothing to go on. Test:
    tests/test_weight_writer.py (1 new).

What was fixed

  • vi-mcp quarantine ended in KeyError: 'herkunft' as soon as an entry the fixed rules held from an instance's own vi_learn
    (0.62.0) waited — the listing assumed every quarantined entry came from the network. Reported from production (13.11.2026, 0.62.4):
    sudo vi-mcp quarantine 30 failed, and with it the person's way to see what to release. Now such an entry is listed with its
    instance, "held by the fixed rules: its author may not release it", and the rule finding. Test: tests/test_release_cli.py (1 new).

  • Searches the query itself emptied were counted as search problems. The reason for an empty search had two values: an unknown
    word (the right answer) or known words that never meet (a search problem). Found on production (13.11.2026, 24 h, read only):
    all 79 empty searches were CentralStation host lookups (host:X) !instanz:centralstation !art:antwort !art:erfahrung; 6 counted as
    "a search problem", although the host occurred only in what the query excludes. A third, named reason ausgeschlossen: the search
    asked again without its exclusions, as the same viewer, finds something — the empty answer was right; the agent is told so, and
    vi_stats E counts it apart. Test: tests/test_vocabulary.py (1 new).

Verify: deploy/pruefe-release.sh <directory> or by hand with openssl, see README.