Egor Miliukov

Over the last couple of years, I ve felt the same frustration a lot of AI builders feel:
LLMs are powerful, but they don t really know who they re talking to.
Every conversation starts from scratch. Your AI assistant forgets user preferences like please keep answers short , it forgets what you discussed last week, and it can t reliably recall that the person on the other side is an experienced dev at a startup, not a beginner.
We have incredible models, but when it comes to long-term interaction with a human, they re basically goldfish.
Today, I m excited to share something I ve been building to fix that:
GetProfile is now open source a drop-in LLM proxy that gives your AI agents user profiles and long-term memory.
It s Apache-2.0 licensed, self-hostable, and designed to slot into existing OpenAI-style stacks with minimal changes.
Why another memory layer ?
A lot of smart people are already working on AI memory.
Projects like Mem0 describe themselves as a universal memory layer for AI agents , focused on storing and retrieving user interactions so assistants can remember preferences and context over time.
Supermemory pitches a scalable plug-and-play memory infrastructure and a Memory OS for AI apps, with APIs, SDKs and a Memory Router to attach persistent memory to any stack.
I love that this space exists. But I also kept noticing a missing piece in my own projects:
Most memory solutions are great at storing facts and messages.
What I wanted was a way to maintain an evolving user profile.
Not just everything they ever said , but:
- What s this user s communication style?
- How advanced are they in this domain?
- What are their stable preferences?
- What events in their history actually matter?
In other words: I wanted something that looked less like a blob of text and more like a structured, typed profile that evolves over time.
So I pivoted GetProfile AI to become exactly that.
From profiling API to LLM proxy with memory
GetProfile originally started as an AI-powered profiling API: send it raw data (chat logs, onboarding forms, CRM records, game events) and it would return structured profile information and summaries you could plug into your existing tools.
That was useful, but the more I talked to indie hackers and founders building agents, the clearer one thing became:
They didn t just want profiles over there in some API .
They wanted their AI agents to "actively use" those profiles in every conversation.
So I rebuilt GetProfile as an LLM proxy and made it open source.
Now the flow looks like this:
1. Your app or agent sends a normal OpenAI-style request but to the GetProfile proxy.
2. GetProfile loads the user s profile and relevant memories from its database.
3. It injects a compact profile summary, traits, and selected memories into the prompt as a system message.
4. It forwards the enriched request to your actual LLM provider (OpenAI, Anthropic, OpenRouter, etc.).
5. It streams the response back to you.
6. In the background, it analyses the interaction, extracts new traits and memories, and updates the user profile.
From your agent s perspective, it s still just OpenAI . Under the hood, it now has a brain that actually remembers who it s talking to.
What GetProfile actually does
At a high level, GetProfile does four things for you:
1. Captures
It receives conversations between your users and your AI via an OpenAI-compatible chat completions API.
2. Extracts
It uses LLM analysis to extract structured traits (like expertise level, tone preference, interests) and important memories (events, milestones, recurring topics) from those interactions, and associates them with a user profile.
3. Injects
For every future request tagged with the same profile ID, it injects a system message that includes a short profile summary, typed traits, and a small set of relevant memories.
4. Updates
It keeps the profile evolving over time: traits can grow more confident or be overwritten, memories can be summarized and pruned, and the profile stays in sync with how the user actually behaves.
The key difference from many other solutions is that the profile is structured.
Instead of storing raw text blobs, GetProfile turns user understanding into typed fields with confidence scores and importance levels, backed by a PostgreSQL schema you can inspect, query, and integrate with the rest of your stack.
For example, a profile might look like this (simplified):
Summary:
Alex is an experienced software engineer who prefers concise, technical explanations. They mostly work in Python and have been exploring distributed systems lately.
Traits (with confidence):
`expertise_level`: `advanced` (0.8)
`communication_style`: `technical` (0.7)
`interests`: `["Python", "distributed systems", "ML"]` (0.6)
Memories (with importance):
Mentioned working on a microservices migration last week.
Prefers async/await over callbacks.
This makes both extraction and injection first-class citizens.
You can customize what gets extracted and how it s injected
One of the core design decisions in GetProfile is that you shouldn t be locked into my idea of what a user profile is.
Instead:
- Profiles live in a generic, extensible schema.
- Traits are configured in JSON files you control.
- Each trait can have its own extraction and injection behavior.
For example, you might define a trait like `travel_preferences` with:
- value type: `array` of strings,
- extraction prompt snippet: Extract the user s travel style preferences from the conversation.
- injection template: User prefers: {{value}}.
GetProfile will then:
1. Extract this trait from interactions where it s relevant.
2. Store it alongside other profile data.
3. Inject it into prompts when it matters.
You can keep things minimal (just a couple of traits), or build a rich personality/intent schema for your agents.
Why open source?
There are a few reasons I decided to ship this as open source:
1. Trust and transparency
Memory and profiles are sensitive. If you re going to let an external service sit in the middle of all your LLM traffic, you need to know what it does. With GetProfile, you can read the code, run it on your own infrastructure, and audit the entire data flow.
2. Self-hosting as a first-class option
GetProfile is meant to be deployed in your environment:
Lightweight proxy built with Hono
Persistent storage in PostgreSQL
Docker-based deployment for easy scaling with Compose or your orchestration of choice
3. Community and experimentation
I don t believe there will be a single correct way to do AI memory or profiling. Different apps will want different traits, models, heuristics, and architectures. By open-sourcing the engine, I m hoping other builders can extend it, plug it into their agents, and help explore what good user memory actually looks like in practice.
4. A sustainable path to a cloud version
On top of the open-source core, I m planning a managed GetProfile Cloud for teams that don t want to self-host. The open-source and cloud versions will share the same engine, but the cloud will add things like a hosted dashboard, usage tracking, multi-tenant management, and batteries-included scaling. You can already join the waitlist from the main site.
Who is GetProfile for?
In its current MVP form, GetProfile is already useful if you re:
- Building an AI assistant or agent and you want it to remember user preferences and personality over time, not just the current thread.
- Running a customer support bot that needs to adapt to plan tier, frustration level, tone preference, and past issues.
- Designing an AI tutor or coach that should build a picture of the learner and tailor explanations over weeks or months.
- Creating a game with AI-driven NPCs or systems that react to player behavior and evolving player profiles .
If your stack speaks OpenAI , you can integrate it just by changing your base URL and adding a couple of headers for profile IDs and upstream provider keys.
What s inside the MVP today
Right now, the OSS MVP includes:
- An OpenAI-compatible proxy with streaming support.
- A PostgreSQL-backed profile + memory store.
- Configurable trait schemas and prompts via JSON.
- Automatic extraction of summaries, traits, and memories from conversations.
- Automatic injection of profile + memories into prompts as a system message.
- Docker setup for easy deployment.
- A growing set of docs covering concepts, quickstart, configuration, and the JavaScript/TypeScript SDK.
It s early. There are a lot of features I want to add: more granular control over what gets injected, better memory summarization, richer analytics, integrations into other ecosystems, and more.
But the core loop capture extract inject update is already working.
How to try it
If you want to play with it:
1. Visit https://getprofile.org for the overview and docs.
2. Clone the repo from GitHub and start it with Docker.
3. Point your existing OpenAI client at the GetProfile proxy and set `X-GetProfile-Id` to whatever user identifier you re using.
If you like what this is trying to do, a star on GitHub or a tiny comment about your use case would mean a lot.
I d also love to hear from you if you re:
- Building agent frameworks or orchestration tools.
- Working on long-term AI products (co-pilots, tutors, assistants, games).
- Interested in experimenting with different trait schemas and profiling strategies.
GetProfile is still small and early, but I think user profiles and long-term memory for AI agents is a layer that needs to exist in the open not just as a closed black box.
If that resonates, come hack on it with me.