| ▲ | buryat 6 hours ago |
| I just wrote a tool for reducing logs for LLM analysis (https://github.com/ascii766164696D/log-mcp) Lots of logs contain non-interesting information so it easily pollutes the context. Instead, my approach has a TF-IDF classifier + a BERT model on GPU for classifying log lines further to reduce the number of logs that should be then fed to a LLM model. The total size of the models is 50MB and the classifier is written in Rust so it allows achieve >1M lines/sec for classifying. And it finds interesting cases that can be missed by simple grepping I trained it on ~90GB of logs and provide scripts to retrain the models (https://github.com/ascii766164696D/log-mcp/tree/main/scripts) It's meant to be used with Claude Code CLI so it could use these tools instead of trying to read the log files |
|
| ▲ | aluzzardi 5 hours ago | parent | next [-] |
| Mendral co-founder here and author of the post. This is an interesting approach. I definitely agree with the problem statement: if the LLM has to filter by error/fatal because of context window constraints, it will miss crucial information. We took a different approach: we have a main agent (opus 4.6) dispatching "log research" jobs to sub agents (haiku 4.5 which is fast/cheap). The sub agent reads a whole bunch of logs and returns only the relevant parts to the parent agent. This is exactly how coding agents (e.g. Claude Code) do it as well. Except instead of having sub agents use grep/read/tail, they use plain SQL. |
| |
| ▲ | buryat 5 hours ago | parent [-] | | yeah, I saw Claude Code doing lots of grepping/find and was curious if that approach might miss something in the log lines or if loading small portion of interesting log lines into the context could help. I find frequently that just looking at ERROR/WARN lines is not enough since some might not actually be errors and some other skipped log lines might have something to look into. And I just wanted to try MCP tooling tbh hehe Took me 2 days to create this to be honest | | |
| ▲ | aluzzardi 5 hours ago | parent [-] | | From our experience running this, we're seeing patterns like these: - Opus agent wakes up when we detect an incident (e.g. CI broke on main) - It looks at the big picture (e.g. which job broke) and makes a plan to investigate - It dispatches narrowly focused tasks to Haiku sub agents (e.g. "extract the failing log patterns from commit XXX on job YYY ...") - Sub agents use the equivalent of "tail", "grep", etc (using SQL) on a very narrow sub-set of logs (as directed by Opus) and return only relevant data (so they can interpret INFO logs as actually being the problem) - Parent Opus agent correlates between sub agents. Can decide to spawn more sub agents to continue the investigation It's no different than what I would do as a human, really. If there are terabytes of logs, I'm not going to read all of them: I'll make a plan, open a bunch of tabs and surface interesting bits. | | |
| ▲ | prescriptivist 4 hours ago | parent | next [-] | | I have an agent system analyzing time series data periodically. What I've landed on is the tools themselves pre-process time series data, giving it more semantic meaning. AKA converting timestamps to human dates, additionally preprocessing it with statistical analysis, such as calculating current windows min/mean/max value for the series as well as a the same for a trailing window and surfacing those in the data. Also adding a volatility score, and doing things like collapsing runs of similar series that aren't particularly interesting from a volatility perspective and just trying to highlight anomalous series in the window in various ways. This isn't anything new. It's not particularly technical or novel in any way, but it seems to work pretty well for identifying anomalies and comparing series over time horizons. It's even less token efficient on small windows than piping in a bunch of json, but it seems to be more effective from an analysis point of view. The strange thing about it is that it involves fairly deterministic analysis before we even send the data to the LLM, so one might ask, what's the point if you're already doing analysis? The answer is that LLMs can actually find interesting patterns across a lot of well presented data, and they can pick up on patterns in a way that feels like they are cross-referencing many different time series and correlate signals in interesting ways. That's where the general purpose LLMs are helpful in my experience. Breaking out analysis into sub-agents is a logical next step, we just haven't gotten there yet. And yeah the goal is to approximate those of us engineers who are good at RCAs in the moment, who have instincts about the system and can juggle a bunch of tabs and cross reference the signals in them. | |
| ▲ | azinman2 4 hours ago | parent | prev | next [-] | | So how can this be a company when it’s just what Claude code already does? | |
| ▲ | almosthere 2 hours ago | parent | prev [-] | | You may want to also have your agents write small scripts that auto flag future logs. Have an array of scripts to run against each log (just rust code probably for speed) and have them flag for performance, errors, intrusions, etc... |
|
|
|
|
| ▲ | ManuelKiessling 5 hours ago | parent | prev | next [-] |
| https://github.com/dx-tooling/platform-problem-monitoring-co... could have a useful approach, too: it finds patterns in log lines and gives you a summary in the sense of „these 500 lines are all technically different, but they are all saying the same“. |
| |
| ▲ | shad42 25 minutes ago | parent | next [-] | | very interesting, curious if there is any downside to running this at scale (compute?) | |
| ▲ | buryat 5 hours ago | parent | prev [-] | | the patter matcher is interesting to also collapse log lines and compare that between runs, thank you! In my tool I was going more of a premise that it's frequently difficult to even say what you're looking for so I wanted to have some step after reading logs to say what should be actually analyzed further which naturally requires to have some model |
|
|
| ▲ | jcgrillo 5 hours ago | parent | prev [-] |
| Do you think it could do anything interesting with a highly compressed representation? CLP can apparently achieve 169x compression ratio: https://github.com/y-scope/clp https://www.uber.com/blog/reducing-logging-cost-by-two-order... |
| |
| ▲ | buryat 5 hours ago | parent [-] | | interesting approach, thanks for directing me! Since the classifier would need to have access to the whole log message I was looking into how search is organized for the CLP compression and see that: > First, recall that CLP-compressed logs are searchable–a user query will first be directed to dictionary searches, and only matching log messages will be decompressed. so then yeah it can be combined with a classifier as they get decompressed to get a filtered view at only log lines that should be interesting. The toughest part is still figuring out what does "interesting" actually mean in this context and without domain knowledge of the logs it would be difficult to capture everything. But I think it's still better than going through all the logs post searching. | | |
| ▲ | jcgrillo 4 hours ago | parent [-] | | I like the idea of SQL as the "common tongue" because provided the query is reasonably terse it's easy for the human to verify and reason about, there's shitloads of it in the LLM's training set, and (usually) the database doesn't lie. So you've mitigated some major LLM drawbacks that way. Another thing SQL has in it's favor is the ability with tools like trino or datafusion to basically turn "everything" into a table. EDIT: thinking on it some more, though, at what point do you just know off the top of your head the small handful of SQL queries you regularly use and just skip the expensive LLM step altogether? Like... that's the thing that underwhelms me about all the "natural language query" excitement. We already have a very good, natural language for queries: SQL. | | |
| ▲ | chickensong 3 hours ago | parent [-] | | > small handful of SQL queries you regularly use Give those queries to the LLM and enjoy your sleep while the agent works. | | |
|
|
|
