Create account
KSOTechGraphBaseProject memory infrastructure
Persistent project context for AIv2.3.1

In every new session,
pick up with
your project.

Add project memory to the pace of your AI development. Bring conversations, code, decisions and tasks into one context. Move forward with Claude Code and Codex, building on previous work.

Discover how it worksExplore the developer layer
Local core MCP integration Context with its sources
Your project's knowledge networkLOCAL PROJECT MEMORY

Choose an example and follow the information.

“Where did we leave off in the image processing project?”devam_et
01 ORIGINAL SOURCES

Your project's accumulated knowledge

ConversationsClaude Code and Codex
Session history
Documents and knowledge notesHandoff notes · Lessons
Technical library
Source codeProject files
Classes and functions

Texts and source references are imported. Code bodies remain in their original files; their locations are indexed.

02 ON YOUR COMPUTER · PERSISTENT

Local memory · SQLite

Text path Conversations · Document sections

Search finds relevant text and evidence of previous work.

Illustrative note: “Preprocessing validation is pending.”

Relationship network Select a node

Decision: Trace its rationale, the code location where it applies and the related work step together.

Conversation text follows a separate information path. Not every message is a graph node.

03 SELECT · RETRIEVE · USE

Context on demand

MCP RESULT · SELECTED INFORMATION
  • Current task and pending step
  • Relevant persistent decisions
  • Recent work context
Claude Code / Codex

The new session starts with open tasks and persistent decisions.

Temporary context of the AI session

If a code excerpt is needed, kod_getir=true retrieves it from the original file. The AI examines the current source before making a change.

New decisions and task progress return to local memory.hafiza_yaz / gorev_guncelle stores a persistent record · Available again in the next session

Smaller starting context · Large CAM example

Same scale · 96.47% fewer estimated tokens · One of four local examples; excludes additional reading. Not a measurement with an actual tokenizer or bill.

Explore this example's four stepsAdd extra reading and calculate the token differenceStart with a briefing; search for the details you need. Additional reading increases context volume.
Conceptual visualization and illustrative examples · Contains no real user data. Colored paths show relationships in the selected example.

Inside your daily AI development workflow

Claude CodeCodexMCP · Model Context Protocol
01Overview

Code moves forward.
Project context should move with it.

A decision made in one AI session may be debated again in the next. The rationale for a Deep Learning experiment may stay buried in conversation history. An issue solved in an image processing pipeline may be investigated again weeks later.

KSOTechGraphBase brings this knowledge into persistent project memory . Supported conversation logs, handoff documents, the code index, decisions and tasks come together in project context. Start a new session with a short briefing, search relevant information and return to the sources of previous work.

AI agent memory + context engineeringAdd a memory layer to your existing AI development tools so they can use your project's history. Claude Code and Codex sessions on the same computer can access shared project knowledge.
02Core capabilities

From scattered information
to usable project intelligence.

Six core capabilities for software development, AI research and engineering automation that make work history searchable, connected and reusable.

Project memory across sessions

Return to Claude Code and Codex conversations. Make project notes and handoff documents part of the context available for the next work session.

Persistent memory · Context continuity

Navigate your code

Find files, classes and functions through the code index. Access relevant locations and, when needed, code excerpts to keep your developer workflow focused.

Code intelligence · Targeted discovery

Decision and task continuity

Record technical decisions, rules, requirements and bug notes. Carry the current task, completed steps and pending work into the next session.

Decision intelligence · Work continuity

Related context through a knowledge graph

Explore relationships between decisions, tasks, files and other project records. When you find information, examine the connected work too.

Knowledge graph · Connected knowledge

Lessons and technical library

Add root causes, lasting solutions and technical notes to project memory. Turn lessons from experiments into reusable knowledge with categories and tags.

Lessons learned · Knowledge reuse

Local dashboard and visibility

Explore memory, search results, tasks and the graph in the browser dashboard. Track source provenance, connection status and information freshness.

Developer experience · Observability
03Workflow

Collect. Connect.
Retrieve. Continue.

Project memory grows within your development cycle. Background updates and direct recording tools connect previous work with the new session.

  1. Bring your project's knowledge together

    Supported session logs, project documents, the source code index, lessons and technical notes provide the sources for memory.

    Conversation history · Project knowledge

  2. Connect information to work context

    Link decisions, code locations and tasks within the relevant project. Consider explicit relationships alongside historical information.

    Knowledge graph · Provenance

  3. Retrieve relevant context when needed

    Request a project briefing, search for a previous decision or locate code through MCP tools. Work with output selected to fit the context budget.

    Context retrieval · Developer workflow

  4. Record the outcome of new work

    Add persistent decisions and task status to memory. Prepare knowledge for the next session with new lessons and technical notes.

    Continuity · Reusable knowledge

New and changed conversations and supported documents update in the background. Code index freshness can be tracked; an initial full scan and refreshes can be started with local tools when needed.

04Knowledge graph

How does a question
travel through memory?

Original project files, persistent local memory and context delivered to the AI session serve different roles. Choose an example and follow information from its source to working context in four steps.

Illustrative examples · Project Atlas
The question in this example“Where did we leave off in the image processing project?”

  1. Session logsClaude Code / Codex conversations
    Project documentsHandoff notes, lessons, technical notes
    Source codeFiles, classes, functions

    Documents and code remain in their own project files.

    Import / code indexing

  2. On your computer · SQLite
    Records, code index and knowledge network

    Decisions, tasks, document sections, lessons and code locations.

    DecisionCode
    Conversation text

    Relevant excerpts from previous conversations are found through text search.

    Information is selected for the query

  3. MCP TOOL RESULT
    • Current task and pending step
    • Relevant persistent decisions
    • Recent work context
    devam_et

    The starting briefing uses information selected from the project's accumulated knowledge.

    Added to the AI session's context

  4. Claude Code / Codex

    The new session starts with open tasks and persistent decisions.

    Temporary session context

    The AI client and its model service are separate components from the local memory core.

Step 1 / 4 · Start a new session

Project knowledge comes from original sources.

What is here?

Previous sessions, project documents and source code files.

What happens in this example?

Conversations, handoff notes and code locations from previous work become sources for memory.

What moves to the next step?

Conversation and document text, source references and code index information.

devam_et({"proje": "Proje Atlas"})
Write back to local memory: A new persistent decision or task status, hafiza_yaz / gorev_guncelle adds to the knowledge available for the next session through this call.

Where is information stored?

Original sources and information in local project memory
Information typeOriginal sourceStored in local memory
ConversationsClaude Code / Codex session filesExtracted user and assistant text; role, time and source information
Documents and technical lessonsThe project's Markdown documentsSelected sections, headings, source references and freshness information
Decisions and tasksDocument record or direct tool callDecision text and status; current task, completed and pending work
Source codeComplete code in project filesFile and symbol locations, signatures, short descriptions and line ranges
Knowledge networkRelationships between project recordsLinks between decisions, tasks, files, symbols, lessons and technical sources

Conversation evidence and graph context come together. Conversation excerpts come from text search; related decisions, tasks and code information come from the knowledge network. Not every conversation message is a graph node.

Code comes from the original file when needed. kod_getir=true retrieves the relevant code excerpt from the file identified by the index. Index freshness matters; the current source file is checked before a change.

Distinguishing current and older decisions and tracking source references helps you evaluate historical information. Relationships extracted from text may involve interpretation. The project, questions and context fragments in these examples are illustrative.

Compare the token impact of selected context · Back to the knowledge network above
05Developer & MCP

Context engineering,
in your daily developer workflow.

MCP lets the AI client call tools in project memory. With KSOTechGraphBase, connect new session startup, code discovery and decision recording to the same memory layer.

01 / Resume the project
// Illustrative MCP tool call
devam_et({
  "proje": "Proje Atlas"
})
02 / Query a previous decision
// Illustrative MCP tool call
hafiza_ara({
  "proje": "Proje Atlas",
  "sorgu": "ön işleme kararı",
  "konusma_dahil": true
})
KSOTechGraphBase MCP tools and functions
ToolRole in the development workflow
devam_etGet a short starting briefing with the current task, persistent project information and recent work context.
hafiza_araQuery decisions and project information. Include conversations and automation sessions in search through options.
kod_araFind a file, class or function location; request a relevant code excerpt when needed.
hafiza_yazSave a decision, rule, requirement, bug or note with a title and content to the relevant project.
gorev_guncelleUpdate the current task, completed steps and pending work for the next session.

Examples show MCP tool names and parameter structure; they require no separate JavaScript SDK. Calls are made by the AI client. A project summary can also be generated from the command line without an AI call.

One project, shared knowledgeA persistent decision recorded with Claude Code can also be queried in a Codex session on the same computer. Project selection determines which working context the information belongs to.
06Context efficiency

From extensive history
to focused working context.

Start with a selected briefing instead of reading entire long handoff documents in every session. When you need details, query the relevant decision, conversation or code location separately.

Work within a context budget

Tasks and persistent project information contribute to starting context. The output budget limits unnecessary repetition and makes room for relevant information.

Selective retrieval

Access project information in Turkish

Search normalizes uppercase, lowercase and Turkish character variants. For example, spellings such as “görüntü” and “goruntu” help access the same information.

Turkish search support

How selection affects context

Compare the full handoff text with briefing + targeted extra reading on the same scale.

Estimated context tokens
Short briefingTargeted search / code reading
Reduced estimated context54.740Fewer input context tokens in 1 session
Context reduction96.47%The number of sessions changes the total difference, not the percentage.

Comparison: full handoff text × session count versus (briefing + extra reading) × session count. You can change the values to match your own work assumptions.

Measurement scope: Four local development examples compared complete handoff documents with short briefings, showing approximately 48–96% less starting context. These are not consumption values measured with the model's actual tokenizer or an API bill. Extra reading and session count in this visualization are scenario values you choose.

System and tool instructions, other chat content, model output and provider pricing are excluded. Larger search output or more code reading increases total context; substantial extra reading can reduce or reverse the advantage.

07Developer visibility

See what happens
inside your memory.

The local browser dashboard lets you explore records, conversations, tasks and connections together. Tool connections, information freshness and backup status stay visible in daily use.

MemorySearchTaskNetworkDiagnosticsProjects

Source traces and diagnostics

Explore source provenance, old record markers and graph relationships. Gain visibility into delivered context, estimated token volume, recent tool usage and connection status.

Human and automation sessions

Automation sessions are excluded from default recent conversations and conversation search; they can be included on request. Sessions with unknown provenance remain visible.

Session classification uses provenance information in source files. Message content alone is not used to decide that a conversation is automated.

08Local-first architecture

Your project memory,
grounded locally.

The memory core runs on your computer. Normal memory, search, code index and dashboard use requires no separate cloud database, API key or internet connection.

Local memory + optional AI assistance

Core functions

Project information is stored locally. An installation approach requiring no Docker, external database or additional Python packages lets you use the memory layer on your own computer.

Optional decision distillation

Using AI to extract persistent decisions from older conversations is a separate feature, disabled by default. It sends selected conversation text to the Anthropic API and requires an API key, internet access and cost approval.

The scope of the connection is explicit. A locally running core does not mean Claude Code or Codex model services run offline. Data flows for external AI operations depend on your client and provider.

Secret masking and record checks

Known password, API key and token patterns are masked during import and output. Decision or task records containing secrets may be rejected. These checks do not guarantee recognition of every secret in every format.

Backup and restore

Daily automatic backups and manual copies help protect accumulated work. A safety copy is created before restoration; checks address open applications and interruptions.

Local memory and backups are files on your computer. Access permissions, device security and external AI preferences are part of your working environment.

09AI · Deep Learning · Computer vision

Your development domain changes.
Accumulated context keeps its value.

From AI research to image processing, from software development to engineering automation: keep the rationale behind model and tool choices accessible alongside code.

Turn experiment history into project memory.

Deep Learning work accumulates data preparation rules, model selection decisions, evaluation notes and code changes. Query these reasons in a new experiment session to retrieve the context of previous work.

Experiment contextAI researchModel decisions
Illustrative memory query

“Why did we change our data augmentation choice?”

Examine the relevant decision record, experiment note and data preparation code location together.

Example context: decision · technical note · code index

KSOTechGraphBase stores the project context of experiments. Model training and inference take place in your Deep Learning tools.

Preserve your computer vision pipeline's decision history.

Preprocessing choices, root causes of image processing errors, OCR tool selection and pipeline changes can become part of project memory. Find solution notes, relevant code and pending tasks together.

Computer visionImage pipelineIssue resolution
Illustrative memory query

“Which change solved the low-light thresholding issue?”

Return to the recorded solution lesson, related function and conversation context of the change.

Example context: lesson · function · conversation

Image analysis, OCR and pixel operations are performed by the project's image processing tools. The memory layer stores their textual context and code index.

Keep work continuous in AI-assisted engineering.

Bring technical decisions, calculation approaches, file and symbol locations and automation tasks together in project context. After long development sessions, start new work with accumulated tasks and decisions.

Engineering knowledgeAI codingWorkflow continuity
Illustrative memory query

“What work remained in the converter, and which file were we editing?”

Query pending steps in the current task and relevant code locations; continue with the current source file content.

Example context: task · file · persistent decision

Each project is queried in its own context. New technical decisions are verified with the developer's tools and engineering checks.

10Setup and compatibility

A memory layer
for your local workflow.

The Windows installer lets you manage project folders and AI tool connections in the local dashboard. Restarting AI applications after installation activates the new plugin version.

End-user installation

EXE distribution

Includes the Python runtime; no separate Python installation is needed. A standard user installation requires no administrator permission.

Development installation

Source / ZIP distribution

Runs on Python 3.10 and later. The application core uses the standard library; no additional package installation is needed.

Target platform
Windows 10 / 11 · 64-bit
Direct integration
Claude Code and Codex · MCP tools
Management interface
Local browser dashboard · Projects, search, tasks and knowledge graph
Core dependencies
No external database, Docker or API key required
Optional external AI
Anthropic API key, internet access and cost approval for decision distillation
Scope of this page
KSOTechGraphBase 2.3.1 · October 8, 2026
11Frequently asked questions

What you want to know
before getting started.

What exactly is KSOTechGraphBase?

It is shared local project memory for Claude Code and Codex. It brings conversations, project documents, the code index, decisions and tasks together, and lets you query relevant context through MCP tools.

Does it train its own AI or Deep Learning model?

The product stores development project context and makes it searchable. Deep Learning model training, image analysis, OCR and inference are performed with your ML or image processing tools.

Can I use it without internet?

The memory core, search and local dashboard need no internet. Claude Code and Codex AI model services have their own connection requirements. Optional external AI decision distillation requires internet and an API key.

Is my data sent to an external AI provider?

Core memory functions run locally. If you enable optional decision distillation, conversation text selected for that operation is sent to the Anthropic API. How your AI client processes context also depends on that client and its provider's operating conditions.

Can Claude Code and Codex use the same memory?

Yes. Clients connected to the same memory installation on the same computer can access shared project knowledge. Conversation sources, project decisions and tasks can be queried by selecting the relevant project.

Will automated conversations overwhelm search?

Sessions identified as automated by their provenance are excluded from default conversation search and recent briefing conversations. They can be included again through a tool option or dashboard checkbox. Sessions with unknown provenance are not hidden.

How does “learning from lessons” work?

Technical lessons such as root causes, solutions and approaches to avoid are stored as records; their code relationships can be defined. This builds searchable knowledge for later work. This workflow does not train model weights.

Does it support Turkish search and source verification?

Search normalizes Turkish characters and letter variants. Source references and historical markers help evaluate found information in context. Technical conclusions require reviewing the relevant source's current content.

How are passwords and keys handled?

Known secret patterns are masked during import and output; decision and task writes containing secrets may be rejected. Pattern-based checks do not guarantee catching every secret format. Memory and backup files should be protected by your device's access and security rules.

Project memory for AI development

Start your next session
with your project's knowledge.

From conversations to decisions, from code to tasks: make project context part of your daily AI development workflow with KSOTechGraphBase.

Explore the MCP workflow