tarasglek

36TB drives are going to enable RAG and agentic workflow per marketing. I would love to lock 5ose marketoids in a room and not let em out until they show demo rag that works better with 36tb than 22tb hd

There is an option in feed settings:

[x] Fetch original content

But most power comes from URL rewrite rules. Here is the one I use for problematic sites:

rewrite("^(.+)$"|"https://markdown.download/$1")

I love that I can pull whole articles. I wrote https://markdown.download for llm use, but mostly ended up using it with miniflux to fetch full articles from problematic sites

Colbert, colqwen are underserved would benefit from a latency optimized inference service

--no-score-check didn't help, so i didn't include it.

Works with your fix.

I sent you an email to schedule a chat. Hope you don't mind. I'm very thankful for your work in this space. Will keep testing this in place of my eget workflows.

Some thoughts so far:

1. ability to pick my own dir or to default to .local/bin . Eg I love using eget from ansible to drop various useful binaries

2. Ability to override github url, so I could do my own token management/cache in a centralized way. This would fix the biggest downside of such tools in CI.

3. It would be nice if there was an option to build go apps. Eg terraform(which you have a workaround for), and obscure stuff like https://github.com/Mic92/ssh-to-age/tree/main . I love that go makes this easy https://bsky.app/profile/taras.glek.net/post/3lcau3yaftc2n

4. lazy mode. I have an ad-hoc script to lazily download various nice-to-have-but-heavy binaries into devcontainer on my team. Eg it's a bash script that checks if usql is in path, if it's not, it downloads a pinned version and runs it and passes args through. Given how fast most binaries are this is the only way to have all the binaries we need without wasting gigs of space of stuff that only 1 person on team may use.

DuckDB binary downloaders compared

`eget` wins:

    eget duckdb/duckdb
    2 candidates found (unsure architecture): please select manually
    (1) duckdb_cli-osx-universal.zip
    (2) libduckdb-osx-universal.zip
    Enter selection number:

Afterwards it correctly unzips. Can use cmdline flag to match artifacts

`gah` fails:

    gah install duckdb/duckdb
    Fetching release info for: duckdb/duckdb [latest]
    Found release: v1.1.3 Bugfix Release
    Downloading:
    Warning: output file name has no length
    curl: option -o: is badly used here

(Using curl 8.4.0 on macOS)

`dist` also fails:

    dist install duckdb/duckdb
    • determining latest version 
    • version: 1.1.3
    ⨯ no matching asset found, score too low
    ⨯ closest matching: duckdb_cli-osx-universal.zip (34) (threshold: 40)

yes, i added it to my blog post, will investigate

Here is my HN submission about eget: https://news.ycombinator.com/item?id=41479539

It's great to see movement in this space. The main problem in my experience is github api and throttling. It's really hard to download 40 binaries while building an image for CI/CD. Binaries themselves are CDNed, but github apis to find them are easily throttled, especially behind NAT.

Need to have some caching mechanism avoid this. Eget seems currently abandoned, maybe gah can start looking stuff in a cache.

Wow, I didn't expect an answer with a product and source. This looks really good, gonna give you guys a try.

Seems like like doing a proper relational 1:N chunk:multiple-vectors foreign key, binarization and a clever join or multistage CTE would get us pretty close to useful.

I am ok with it being less efficient as the dev ux will be amazing. Vespa ops (even in their cloud) are a complete nightmare compared to postgres

Looks like that there is recent work to make a pgvector example for this https://github.com/pgvector/pgvector-python/blob/master/exam...

I am still waiting for a good pattern for using multivector embeddings like ColBert and ColPali in postgres. I get that its fun to optimize single vector stuff, but multivector is that happy middleground between single vector and reranker that seems to be only validated in specialized exotic search dbs like Vespa

I am not a gamer, but I found that https://moonlight-stream.org/ latency when streaming from my server to mbp is lower than that of my projector directly connected to said server. Might be easier to just get a beefy server with gpu passthrough than fight 10gbe drivers on 10 machines. Amd cards seem to work amazing for passthrough.

I wrote chatcraft.org for dev and mobile use cases. It can run code for validation does voice input. Anthropic is the first ui that's end competitive, aider is another interesting one. Special trick in chatcraft is that it allows using very advanced models for free without any signups and logins

I agree re simplicity of the old way of doing things. There's another benefit that most cgi-bin systems had: lack of build step or exotic runtime requirements.

Eg, you'd drop some html into public_html folder and an executable into cgi-bin dir. I would performance engineer some scripts into C++ binaries and just checkout the source & run make to produce binaries in-place. This approach made it easy to use local dev tooling to test/debug stuff instantly via oldschool emacs TRAMP/sshfs.

There is a system that replicates the simplicity of what we lost (while letting you use fancy modern JS frameworks): https://www.smallweb.run/. It also offers a path to cloudflare-like edge computing migration without any code change via deno deploy. With smallweb, one drops a bunch of files into own dir (eg, you could give a dir to each student), which results in https://<dir>.domain.name running stuff ondemand in that dir. No build step, no exotic runtime to transpile into, full ability to use local dev tooling to test/debug stuff instantly. It's still early days for smallweb, but it's specifically designed with the philosophy of "edit some files and stuff runs..while remaining compatible with standard deno way of doing things".

I love the concept of cloudflare workers[1], their fancy state management, bindings, etc, and the fact that they took inspiration from cgi-bin. However, the fact remains that it's an exotic system with weird restrictions (hello changing your apps around 500mb chunk limits ala https://github.com/cloudflare/serverless-registry). This limitation can make it difficult to work with libraries that aren't tested against the cloudflare runtime. 90% of code I write would run better with cloudflare than with deno (due to awesome cold startups), but dealing with these restrictions is too much engineering overhead upfront.

In contrast, with deno/smallweb, I just drop some files into a directory, don't need to bother with package.json, lockfiles, etc, but can gradually opt into those and then gradually switch to CI/CD mode of operation. You can't expect a student new to web development to deal with the exoticness of cloudflare's solution from day 0.

[1] Kenton, it's a fantastic design, I sang praises to it in https://taras.glek.net/posts/cloudflare-pages-kind-of-amazin.... But after trying equivalents in deno ecosystem like val.town and smallweb I would love for it to be less exotic(I know you guys have more node compat work happening).

I would love an editable table example. You have the edit/delete icons wired up, would love to see what enabling those looks like in practice

SambaNova does bf16

I had dev who praised next, turned out he had no idea when his code ran on client or server.

All the the hate for json here, but at the bottom there is a bridge screenshot. Varlink is designed such that it can trivially be piped across different systems and be maximally interoperable due simple to parse and encode protocol. We might end up with some IPC interface that a lot me tooling can understand. Eg imagine that instead of some daemons supporting sighup to reload, they could also confirm that they reloaded, provided Prometheus style metrics etc

This is why I switched to deno deploy. Much of the same benefits and much more portable stack.

I love they built all this infra for running js to avoid building a container runtime and ended up building a container platform using all the hypervisors. On more serious note, I do not understand why they can't fix the 500mb upload limit. I hit that with r2 registry and ended switching away instead changing all the dockepush tooling. Not super excited re using more weird tools rather than fixing platform

I like this, can we have cdc notifications for table writes and DO reacting to them behind that output gate too?

That's cool that you guys are looking beyond s3 for distributed primitives

It would be helpful to document your architecture. Eg what kind of text search you use, eg trigrams, some sort of benchmark for searching with/without expensive embeddings.

Yeah no way to ask for openapi schema definition.

built https://chatcraft.org over the past 1.5 years. I felt chatgpt was too limiting from being proprietary. Can run js,ts,python inline. I find it to be a much better tool than copilot for my usage, cant live without it.

Im a little jelly of the artifacts feature in claude. Been wanting something like that but their design is better than any of my ideas.

Awesome, thank you

Russia was biggest trading partner for Ukraine after fall of USSR. They decided it looks bad that Ukraine isn't part of Russia.

I found mobiscribe devices to be an amazing value. Got usable android(still very buggy) but without the usual Chinese spyware. Bought mine for $99 from them. Use it for most of my reading.

Does graphene actually setup nested virt? From my research nested virt on android never got any community traction. no usable soluons.Am I wrong?

This looks cool, but I'm confused as to how this is surfaced in your product, llama-8 is not present in your model list.

I thought maybe you offer hallucination detection, but I also don't see that. RAG evals also not visible