Skip Navigation

Posts
5
Comments
271
Joined
3 yr. ago

Interests: programming, video games, anime, music composition

I used to be on kbin as e0qdk@kbin.social before it broke down.

  • OK, so there's a few things I've built. First, I want to clarify that there's the concept of a "tool call" in LLMs. i.e. the LLM generates a specific sort of response which is intended to be interpreted as a request to run a function (either in llama-server [if you enable that] or in your client). The LLM needs to be provided with a list of the tools that are supported (including the name of the tool, the description, and arguments) for it to know that it can call them.

    Basically, you send a prompt, the LLM "thinks" for a bit, it spits out a tool call as the response, the client code sees the tool call, runs the appropriate function, then submits the result back as another prompt to the LLM and it continues on generating a response.

    I've built custom tools (in my own custom client) for accessing limited parts of my file system in a particular read only fashion. (I do not trust these things to write to my disk autonomously...)

    For example, I have a find_files tool that LLMs can call with a project name (which I need to provide -- restricted to a few specific locations based on a config file) and which basically runs a listdir and returns the results as JSON to the LLM. I also have a read_source_code tool that allows specifying a project and a file and it will return the text of that file.

    This is technically redundant with features that are available out-of-the-box in llama-server but I'd rather run llama-server locked down in a container and provide it access with no more than I want it to have from code I control.

    The custom client I wrote includes my own web UI (which is simpler than the one that comes out of the box with llama-server but is tailored to my specific tastes), and the code to run those custom tool calls. The first pass was also my first serious experiment with vibe coding; I wrote a very simple skeleton by hand and then iterated on it allowing the LLM to write most of the code so I could see what that process was like and how it would go wrong. As you might expect, that turned into a complete mess and I scrapped and rewrote pretty much the whole whole thing after a few weeks, but it was quite educational!

  • Are you just using it like a chatbot in this situation?

    For short snippets, I usually just paste the code in (e.g. using triple backticks to indicate a codeblock with Markdown if I want distinguish it clearly from other text in my prompt). It's also possible to drag-and-drop files into the web UI that ships with llama-server, and I also have some of my own custom tooling.

    How are you giving it things like binary files? Does it actually understand them? Is that a feature of only certain models?

    Vision Language Models can work with images. Both Qwen and Gemma can do it. In the web UI, you can just drag and drop images in and they'll be added as attachments that get processed along with your prompt text. There's limits to what they can understand -- I recommend experimenting with them to get a sense of it -- but for things like OCR, they just do it...

    I've also implemented handling for passing images into models via code if you're curious about that as well -- basically you just add the file as base64 encoded data in the JSON structure that you POST to the server.

    llama-server's web UI can process PDFs too, but I'm not sure on what it does for that exactly under the hood.

  • I can't give you much advice about Claude or Copilot since I refuse to use either, but I do use open weight models which I can run on my own hardware.

    If you're interested in exploring LLMs from that angle, download llama.cpp and some models that'll fit on whatever hardware you've got and start poking at it. I got started a few months back, and it's been an interesting experience. llama-server (which is one of the tools that comes with llama.cpp) includes a web UI. You can also use llama-cli on the command-line (but that gets old pretty quick).

    Gemma and Qwen are the two most popular open weight model families right now since they're small enough to run on local hardware and give good enough results that they can be useful.

    I've found them to be useful for:

    • debugging assistance (e.g. Qwen often points out typos I've made in Python scripts that would've taken me a while to find otherwise)
    • brainstorming (think: interactive rubber ducky you can bounce ideas off of -- set a system prompt telling it NOT to give you code though unless you explicitly ask for it for this use case; they're too eager to write code otherwise)
    • OCR
    • natural language to JSON data extraction (e.g. here's an email, here's a reference table, here's an example of what I want, extract the data from the email into similar JSON...)
    • prototyping web UIs (e.g. here's the HTML skeleton for [insert project here], write CSS to style it; here's a screenshot of how it looks now, fix the bug that causes [issue] in the CSS; iterate)
    • light scripting (e.g. straightforward but tedious tasks that can be handled by a ~100 line or less Python script)
    • quick search/snippet generation for things that I would've done by Googling for a link to documentation/stackoverflow a few years ago -- this works well enough for webdev questions; YMMV with other subjects
    • answering questions based on reference data buried somewhere in a PDF

    If you try to do batch processing with them, it's helpful to think about them like a flaky distributed system -- i.e. use timeouts, retries, error handling mechanisms that account for invalid output, etc.

  • If I understand the nature of your hardware correctly, you should be able to run the MoE models like Gemma4 26B-A4B or Qwen3.6 35B-A3B at a high quantization fairly performantly.

    You could try running some of the dense models (like today's Qwen 3.8 27B) as well, but I expect they'll be pretty slow (judging by my own experience with a unified RAM system that has a Strix Halo APU). Might still be useful for tasks that you can leave running on their own for a long time instead of for interactive chat style interaction though.

    You've got enough RAM to load larger models, but there hasn't been much released in between the "it fits on a 24GB or 32GB GPU that a gamer might own" and the "oh god you need HOW MUCH RAM!?" scales lately...

  • How much RAM do you have?

  • In my testing so far, it seems to lean more into "I don't know" type answers, but I haven't poked at it that much yet.

    One of the queries that used to consistently trip up Qwen 3.5/3.6 was asking directly about a plausible sounding (but non-existent) work (e.g. Are you familiar with "A Valiant Effort (1989)"?); stock Qwen 3.8 will say it doesn't know or isn't sure and ask me for context.

  • LocalLLaMA @sh.itjust.works

    Qwen3.8-27B Weights Released

    huggingface.co /Qwen/Qwen3.8-27B
  • You can also use something like llama-swap to seamlessly swap between them.

    FYI: llama-server has built-in model swapping now so you don't need a second piece of software (at least for the simple cases). I pass --model-presets and a path to an INI file with the per-model parameters when I run the server.

  • 27b is much better though...

    I haven't really found that to be the case for my uses, but getting much faster decode is really useful for me... Have you tried running the MoE model at a higher quant? I usually use Q6_K.

  • qwen 3.6 27b runs on an AMD AI MAX 395+ fairly well.

    Try Qwen 3.6 35B-A3B on your hardware instead; it's much faster.

  • Everything runs well if one is patient enough 😂

    I mean, if you're really patient you can even run with CPU only as long as you have enough RAM... My ~decade old computer with DDR3 RAM gets 14 tok/s prompt processing and ~5 tok/s decode on MoE models (e.g. a Qwen 3.6 35B-A3B variant at Q6_K -- my current default model). That pp tok/s is painfully slow... but it still works!

    Same computer, same model but using a discrete GPU that can fit all the weights on the card -- ~900 tok/s prompt processing, ~70 tok/s decode.

  • ~2 days until 27B release apparently.

  • LocalLLaMA @sh.itjust.works

    meta-models/Muse-Glimmer-30B-GGUF

    huggingface.co /meta-models/Muse-Glimmer-30B-GGUF
  • OK. I think I see what you're getting at. If you can figure out how to get it to the point of an outline, there are triangulation libraries that can fill in the mesh for you (I think I've mentioned one to you before a long time ago) if you want flat end caps on the extrusion. I'm not sure off the top of my head how you'd get to an outline from that star example though -- a few ideas come to mind, but they're very much half-baked ideas... :p

    Best of luck!

    Edit: the triangulation library I was thinking of: https://github.com/mapbox/earcut

  • I'm not sure I quite get it, but if I'm following correctly, you're using the numbers to indicate a sequence of vertices for a triangle fan here (with @ indicating the central vertex), right? If so, the vertices are used in more than one triangle; (0, 1, 2) and (0, 2, 3) are triangles that reuse vertex 0 (@) and vertex 2.

    If that's what's going on then it should be fairly straightforward to turn shapes defined like this into extrusions; for the simplest case you duplicate and offset the triangle fan for the other end and then generate quads/pairs of triangles for the extruded faces of the prism -- and for more complicated cases you can repeat that (with planar alignment if needed) following a curve in small increments.

    I might not be following though since I don't know what you mean by color index face hints.

  • +1 for llmfan46's heretic variants. I use one of his uncensored Qwen 3.6 35B-A3B variants as my default model.

    rpDungeon's Luchador models (gemma derived) are also quite interesting -- they tend to have better prose quality for creative writing tasks.

    I've been curious to try experimenting with using Rudo in particular for making more interesting NPC interactions in a text adventure for a while now, but haven't gotten to it yet.

  • fan vs strip

    Why not just work with a collection of triangles directly? It uses more memory, yes, but it's simpler to reason about and can also have parallelism benefits (since each triangle is independent).

    It can still be useful to track shared vertices (and reference them by index) though.

  • Well, I've seen Fate/Stay Night and Fate/Zero and a few of the other spin offs but I've kind of lost track of the Fate/Word Salad series at this point... 🙃️

  • Having never eaten either, my gut feeling is squirrel... but that's a pure guess.

    No idea how you manage to get whale roadkill though. 🙃️

  • Ooookay then... 🤨

    Please comment with your favorite roadkill recipes.

    I, uh, have never cooked roadkill... but if I were put on the spot I suppose I could try to make gumbo out of it?

    e.g. Make a roux, add chopped celery, onion, bell pepper (Cajun "Trinity"), plus garlic, thyme, bay leaf, salt, black pepper, chicken stock, beer, the meat, and a spoonful of hot sauce (e.g. Crystal or Tabasco). Simmer for 3 hours or more. Serve over white rice.

  • I've been reading a fair bit of old, out of copyright fiction over the last couple years. I recently finished Carry On, Jeeves by P. G. Wodehouse which was amusing. You can find a copy here: https://www.gutenberg.org/ebooks/65974

  • Programming @programming.dev

    Critical Security Vulnerability in React Server Components

    react.dev /blog/2025/12/03/critical-security-vulnerability-in-react-server-components
  • Golang @programming.dev

    Notes about "go: RLock go.mod: no locks available" and similar errors

  • Programming @programming.dev

    Backdoor in upstream xz/liblzma leading to ssh server compromise

    www.openwall.com /lists/oss-security/2024/03/29/4