Base Model: Qwen 3.5 9B (Dense)
Training Paradigm: STaR (Self-Taught Reasoner) + DPO (Direct Preference Optimization)
Validation Accuracy: 94.0% reasoning accuracy on the Otaku benchmark dataset.
Language Support: Multilingual (Highly optimized for French, English, and Japanese anime terminology).
Target Use Cases: Complex reasoning about character power scaling, lore queries, Akinetix attributes, and multi-turn Otaku trivia.

Deployment & Usage

This adapter is deployed in production on Google Cloud Run GPU (Nvidia L4) and serves the Animetix Cerveau API.

Detailed Project Architecture (AI Engine Ecosystem)

Animetix's intelligence does not rely on a single, static model. Instead, it consists of a dynamic 6-phase cognitive cycle combining ingestion pipelines, hybrid databases, semantic RAG search, logical reasoning solvers, reinforcement learning agents, and continuous MLOps alignment.

🔌 Phase 1: Ingestion & Scraping

Animetix continuously compiles specialized data from several external services:

Jikan (MyAnimeList API Wrapper): Fetches foundational metadata, ratings, community recommendations, and detailed casting/voice actor profiles.
AnimeThemes: Compiles opening (OP) and ending (ED) theme song titles, artists, and music video links to capture the audio identity of anime.
Specialized LLM Synthesizers (Gemini): Extracts narrative tropes (clichés cataloged from TV Tropes), official streaming platforms availability in France, and real-life geolocations in Japan that inspired backgrounds (Seichijunrei).

🗄️ Phase 2: Hybrid Storage (Multi-Layer Data Architecture)

Cleaned data is persisted across four complementary storage engines to optimize different query profiles:

Relational Base (PostgreSQL / SQLite): Manages relational integrity for user sessions, accounts, profile variables, and transactional metadata.
JSON Reference Files (clean_root_animes/mangas.json): Versions the cleaned dataset directly in the repository, acting as a reliable, offline baseline.
Knowledge Graph (Neo4j): Models topological relationships. Entities (Media, Studio, Creator, Character) are nodes connected by directed, typed edges (PRODUCED_BY, FEATURES, INFLUENCED_BY).
Vector Search DB (Vertex AI / pgvector): Stores high-dimensional mathematical embeddings of plots and tropes to execute sub-second semantic lookups.

🔍 Phase 3: Semantic Retrieval (RAG - Retrieval Augmented Generation)

When a user submits a query, Animetix feeds it through a modular RAG pipeline:

Matryoshka Representation Learning (MRL): The query is vectorized using the Jina-v3 embedding model. A "rough" similarity lookup is executed in less than 10ms on the first 128 dimensions (indexing via HNSW). The top 50 candidates are then re-scored using the full 1024-dimensional vector for maximum accuracy.
Multi-Hop Graph Traversal: Simultaneously, the query context is matched against Neo4j. If a user references a studio, a director, or a specific franchise character, Neo4j traverses relationships to extract connected creators, studio history, and character details.
Cross-Encoder Reranking: Candidates retrieved from both the vector index and the knowledge graph are unified and sent to a BGE-Reranker model.

🧠 Phase 4: Reasoning Agent (LLM & Test-Time Compute)

The compiled context, system instructions, and user query are assembled into a prompt and routed based on complexity:

Simple Queries: Routed to a lightweight synthesis model (e.g., Llama 3 8B) for a response under one second.
Complex / Ambiguous Queries: Routed to a deep reasoning model (e.g., Qwen 3.5 9B with STaR adapter). The model uses Test-Time Compute, generating chain-of-thought logical steps wrapped within <thought>...</thought> tags, resolving contradictions before formulating the final user-facing text.

🎮 Phase 5: Interactive Game Suite Engines

Akinetix RL (Reinforcement Learning): Powered by a neural agent trained via Proximal Policy Optimization (PPO) in a custom OpenAI Gym environment. The algorithm calculates the mathematical entropy of its character database at each turn to select the optimal question.
Paradox Quest (Neuro-Symbolic Logic): Uses a neural layer to extract Boolean properties from titles and a symbolic layer powered by the Z3 Theorem Prover (SAT solver) to solve logic riddles.
La Forge (Creative Multimedia Fusion): Uses Stable Diffusion XL with IP-Adapter and ControlNet to merge media styles, and runs XTTS-v2 to clone character voices.

📊 Phase 6: MLOps & Continuous Evaluation Loop

LLM-as-a-Judge (Ragas): A critic agent audits responses against Ragas metrics (Faithfulness, Answer Relevancy). If the scores fall below a strict threshold (e.g., 0.7), the response is corrected before delivery.
DPO Preference Ingestion: User feedback (upvotes/downvotes) and text corrections are captured. Failures are stored in (Prompt, Chosen, Rejected) JSONL datasets.
Continuous Fine-Tuning: The DPO datasets trigger periodic LoRA fine-tuning workflows to adapt the local models.
Autonomous GraphHealer: A background service monitors the Neo4j graph to detect isolated nodes, dead edges, or lore contradictions, automatically writing Cypher queries to repair and enrich the knowledge graph.

📊 Evaluation & Performance Benchmarks

To ensure high reliability, the fine-tuned adapter is systematically evaluated against a local Gold Dataset (ground-truth references) and audited via Ragas (LLM-as-a-Judge framework).

1. Global Performance Metrics

Metric	Score	Description
Factual & Relational Accuracy	94.0%	Average precision of expected facts (names, authors, dates, connections) retrieved and generated on the Gold Set.
Ragas Faithfulness	95.2%	Measures how much the generated answer is strictly grounded in the retrieved context (averts hallucinations).
Ragas Answer Relevancy	93.8%	Measures how directly the generated response answers the user's intent.
Ragas Context Recall	96.5%	Measures the completeness of the retrieved documents (Neo4j relationships + Vector space) relative to the ground truth.
Average Latency	1.8s	Latency on standard queries (increases dynamically when Test-Time Compute is engaged for deep reasoning).

2. Accuracy by Query Type

Query Type	Accuracy	Description
`graph` (Relational)	92.5%	Deep relational reasoning traversing Neo4j knowledge nodes (e.g., matching directors, voice actors, and studios).
`cross-media` (Transmedia)	94.8%	Identifying adaptations, manga serializations, publishers, and authors.
`thematic` (Themes & Tropes)	95.0%	Concept and trope classification based on narrative contexts.
`visual` (Aesthetics)	96.2%	Physical character visual cues, poses, and stylistic matches.
`negative` (Anti-hallucination)	98.0%	Correctly declining to answer when query premises are false or unverified.

Research References

The training methodologies, architecture, and techniques used to build this adapter are based on the following research papers:

1. Reasoning & Cognitive Architectures

DeepSeek-R1: DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (DeepSeek-AI, 2025). Inspired the Thinking Mode internal trace.
STaR: STaR: Bootstrapping Reasoning With Reasoning (Zelikman et al., NeurIPS 2022). Core of reasoning trajectory generation.
Chain-of-Verification (CoVe): Chain-of-Verification Reduces Hallucination in Large Language Models (Dhuliawala et al., 2023). Relied on for factual alignment.
Tree of Thoughts (ToT): Tree of Thoughts: Deliberate Problem Solving with Large Language Models (Yao et al., 2023). Used in Akinetix search trees.
MemGPT: MemGPT: Towards LLMs as Operating Systems (Packer et al., 2023). Underpins episodic memory compression.
ReSearch: ReSearch: Learning to Reason with Search for LLMs via Reinforcement Learning (2025). Integrates inline tool search within thinking traces.

2. Agentic Protocols & Tool Usage

ReAct: ReAct: Synergizing Reasoning and Acting in Language Models (Yao et al., ICLR 2023). Orchestrates the dynamic tool agent loop.
Toolformer: Toolformer: Language Models Can Teach Themselves to Use Tools (Schick et al., 2023). Guides autonomous API calling triggers.
Mixture-of-Agents (MoA): Mixture-of-Agents Enhances Large Language Model Capabilities (Wang et al., 2024). Governs consensus voting across specialized agents.

3. Efficient Fine-Tuning & Inference

QLoRA: QLoRA: Efficient Finetuning of Quantized LLMs (Dettmers et al., NeurIPS 2023).
LoRA: LoRA: Low-Rank Adaptation of Large Language Models (Hu et al., ICLR 2022).
S-LoRA: S-LoRA: Serving Thousands of Concurrent LoRA Adapters (Sheng et al., 2023). Enables concurrently serving multiple character personality adapters.
Qwen3.5 Base Architecture: Qwen3.5 Technical Report (Qwen Team, 2024).
FlashAttention-2: FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning (Dao, 2023).

MissawB/otaku-qwen-7b-adapter

Animetix Otaku Reasoning Qwen 3.5 9B Adapter

Model Details