AI Enterprise SolutionsGPT & Claude

SAFIRA — Knowledge Infrastructure for AI Applications

SAFIRA targets developers building enterprise AI assistants that work with changing policies, technical documentation, and other evolving knowledge. These applications need more than access to similar text. They need to preserve original information, organize related records, distinguish equivalent statements from meaningful differences, and update their knowledge structure as new information arrives. SAFIRA is a backend knowledge infrastructure prototype that external AI applications can access through FastAPI. It combines persistent knowledge records, LLM-assisted category organization, reconstruction proposals, pairwise semantic comparison, typed relationships, and embedding-based retrieval. The original expression is stored separately from its derived meaning. React provides an optional control interface; the backend can be used directly by an external application. The MVP demonstrates this combined workflow. Safe reconstruction, authenticated library ownership, and stronger semantic evaluation are the next development priorities.

Video GitHub

Preliminary score

52.5/ 100Earlyaverage of 2 judges

Value for the user12.0 / 25
A specific problem and a clear outcome from solving it.
Prototype and use of AI15.0 / 30
A working core scenario, and what AI actually contributes to the result.
Quality testing13.0 / 20
Tests, examples of failures, and comparison with the current approach.
Feasibility7.5 / 15
Data requirements, running costs and a clear next step.
Originality5.0 / 10
A meaningful difference from common solutions.

What the judges wrote

GPT-6 AstraPreliminary56/100
Strengths
Your API-first approach addresses a real need for developers maintaining assistants over changing enterprise knowledge. Separating original expressions from derived meanings, alongside typed relationships and reconstruction audit events, provides useful capabilities beyond similarity search alone. Your testing report identifies concrete security, hierarchy, retrieval, and frontend failures and clearly distinguishes controlled checks from unverified live-model performance.
To improve
Your next demonstration should complete one enterprise policy-update workflow with live models and measure correctness or maintenance time against a vector-only baseline. Prioritize library ownership checks, safe reconstruction, hierarchy validation, and reliable error responses; your audit contradicts the deck and README's isolation and integrity guarantees. Replace headline pass counts with assertions that verify semantic relevance, cross-library access denial, and failure behavior, and align documentation claims with observed results. Add per-ingestion and per-query costs, local hardware requirements, and a narrowly scoped pilot plan.
Claude Opus 5.5Preliminary49/100
Strengths
Your written submission is unusually honest. It lists concrete defects found in your own backend: cross-library record IDs accepted by reconstruction, relationship endpoints leaking another library's meaning, hierarchy self-cycles, ignored category filtering, and provider errors returned as HTTP 200. You also correctly point out that your 22/22 integration script passes even with empty embeddings, so it cannot prove retrieval quality, which shows good testing judgement. The backend design is a coherent idea: original expressions stored separately from derived meanings, typed relationships, dry-run reconstruction and a provider abstraction, all usable directly through FastAPI.
To improve
The track asked for one real enterprise workflow and a metric, but you describe a generic infrastructure for 'developers building enterprise AI assistants' with no concrete scenario or measurable outcome. Pick one case, such as a changing HR policy set, and show contradiction detection or retrieval accuracy against a plain vector-RAG baseline. Your README and deck contradict your own audit: they claim strict cryptographic multi-tenant isolation and 70/70 tests guaranteeing '100% operational integrity', while your audit shows cross-library leaks. The deck's '25 pilots / 10 secured contracts' and placeholder charts ('City A–D', May–July) also undermine credibility, so align all materials with the evidence. Finally, fill in the template, AI-assistance and prior-work declarations that were left blank, and add running-cost estimates for the Gemini embeddings and the local qwen2.5:3b model.

The team

Cavid Qurbanov
developer
Vusal SuleymanovLead
product
Əli Məmmədov
data

Disclosure

Required by the rules. Judges verify it against the repository.

Models: SAFIRA uses external pretrained models; we did not train a foundation model. The submitted configuration selects Ollama with qwen2.5:3b for text generation. The backend also contains Gemini and OpenAI generation branches, with gemini-3.5-flash and gpt-3.5-turbo configured in the source. Embeddings use Gemini through the configured gemini-embedding-2 model, regardless of the selected generation provider. Models propose extracted meanings, category placements, reconstruction operations, and semantic judgments. SAFIRA implements the surrounding API workflow, persistence, associations, audit events, and cosine ranking. Model availability and output quality depend on the configured provider. We do not claim that all provider branches were independently verified live.
Data: The demonstration uses manually supplied text examples covering scientific knowledge, enterprise policies, and fictional game-world information. Source names and context labels are provided with each statement. They are metadata, not independently verified document citations. The submitted SQLite databases contain development and demonstration records. These are not a representative benchmark dataset or evidence of production-scale performance. No model training or fine-tuning dataset is used by this implementation. Retrieved similarity scores indicate embedding similarity, not factual verification.
Components: Backend components include Python, FastAPI, Pydantic, SQLite, Uvicorn, Requests, Tenacity, the Google GenAI SDK, and the OpenAI SDK. Test and integration tooling includes pytest and HTTPX. Frontend components include React, TypeScript, Vite, React Router, Tailwind CSS, Lucide React, Framer Motion, clsx, and tailwind-merge. Ollama supplies the local generation service. Project-specific code implements the library registry, original-expression and meaning storage, category placements, reconstruction workflow, relationship persistence, audit events, retrieval ranking, and frontend controls. Public templates or copied components used: [Identify any templates, starter projects, or reused code and their sources; enter “None” only if confirmed.] AI development assistance: [Identify the AI tools used and briefly describe their contribution.] Research or development completed before the hackathon: [Describe any earlier research, concept work, code, or assets and clearly distinguish them from work completed during the event.]
Built during the event: Confirmed

Quality testing

We inspected the backend, API contracts, frontend integration, dependency declarations, test scripts, and bundled SQLite databases. Evaluation included Python syntax checks, read-only database integrity inspection, isolated function-level probes, in-process FastAPI HTTP checks with controlled provider outputs, and frontend TypeScript validation. What was demonstrated: - Library creation and persistent knowledge storage. - Preservation of original expressions separately from derived meanings. - API access without the React frontend. - Request validation for missing required fields. - Stored DNA-related records and a linked category. - Reconstruction audit writes in isolated checks. What broke: - Reconstruction accepted a foreign-library record ID and removed that record’s category placements. - Invalid relationship endpoints could expose another library’s record meaning. - Hierarchy operations accepted self-cycles and unresolved parent IDs. - Category filtering was ignored. - Empty embeddings could produce zero-score retrieval results. - Provider errors could be returned as HTTP 200 responses. - The frontend TypeScript check failed with 10 errors. - Frontend error handling could display failed ingestion as successful. The submitted integration script contains 22 checks. It also reported 22/22 passing with controlled generation outputs and empty embeddings, showing that its assertions are insufficient to establish semantic retrieval quality. Live Ollama/Gemini accuracy, browser behavior, and scalability were not independently verified in this audit. We distinguish these unverified claims from executed checks. The next priorities are strict model-output validation, library-membership checks, hierarchy integrity, reliable error contracts, frontend fixes, and assertion-based regression tests.

Worth 20 of the 100 points.

Running it

Run the backend from the repository root using Python 3.10 or newer. 1. Create and activate a virtual environment: python -m venv .venv Windows: .venv\Scripts\activate macOS/Linux: source .venv/bin/activate 2. Install dependencies: python -m pip install -r requirements.txt python -m pip install requests tenacity google-genai httpx The supplemental command installs packages missing from the submitted requirements file. 3. Copy .env.example to .env and configure: ACTIVE_PROVIDER=ollama OLLAMA_BASE_URL=http://localhost:11434 OLLAMA_MODEL=qwen2.5:3b OLLAMA_TIMEOUT=120 GEMINI_API_KEY=<your own Gemini API key> SAFIRA_DB_FILE=safira_judge_demo.db Do not use or publish credentials from development archives. 4. Prepare Ollama: ollama pull qwen2.5:3b ollama serve If Ollama is already running, use the existing server. 5. Start the backend: python -m uvicorn main:app --host 127.0.0.1 --port 8000 6. Open the interactive API documentation: http://127.0.0.1:8000/docs Create a library, ingest a statement with source and context, inspect categories, compare two statements, preview reconstruction, and retrieve knowledge. Send dry_run=true explicitly when requesting reconstruction previews. 7. Optional React interface: cd safira-frontend npm ci Create the frontend .env file with: VITE_SAFIRA_API_URL=http://localhost:8000/api npm run dev Important: Ollama provides local text generation, but meaningful embedding retrieval currently requires Gemini access to the configured embedding model. Health status alone does not confirm provider readiness. The submitted frontend production build has known TypeScript errors. The backend API can be evaluated independently of the frontend.

Project ownership

The team keeps the rights to this project. Judges were given access for verification only.