K.Boopathi
BlogNotesSecond BrainProjectsHire MeYour reading file0 pts

LLM learning resources

Feb 02, 20254 min read

https://www.ai21.com/jamba/

https://same.dev/

https://www.agentrecipes.com/

Voice agent

Video

Code

Library

Finanace

Benchmark

Free Voice

  • mimic3
    • A fast local neural text to speech engine for Mycroft

  • opentts

who validate the validator

  • DOmain in

n the context of AI agents, reliability refers to the consistency of an agent in providing correct and dependable results1. It emphasizes the agent’s ability to perform its intended functions correctly and consistently over time, ensuring that users can trust its outputs1. This is especially crucial when agents are deployed for important real-world decisions

Thinking Like Your Agent: Understand the agent’s perspective by limiting yourself to its context window

gemini research Agent

  • long running task
  • context
  • multistep

How to build effective agent

  • dont build agent for everything if some thing can be done by workflow use that

  • think like a agent (put yourself in the agent context

  • how models improve there own tool

codesurf

trajectories : agent will understand by listening what user is doing trajectories meta learning : build a memory bank about the developer scale wit intelligence:

LLM as code where we prompt the LLM to create a page and based on user action LLM will render the page

TODO

  • browser use with ollama
  • build simple UI to try multople prompt tester how the output was
  • pipecat need to check
  • https://www.tensorzero.com/

Voice Agent resources

code review

Jamba

Long context model

LLM as TOOL tips

Instead of forcing the model into a specific format upfront, let the model determine its own natural structure based on multiple examples and then adapt to that.

  1. Let the Model Generate Raw Outputs

    • Instead of telling the model exactly how to format a tool call, just describe the high-level goal and let the model produce multiple (N) mock requests/responses.
    • Example: If your tool needs an API call for weather data, ask the model: > “Generate a request and response for fetching weather data.”
    • Do this multiple times to see variations in how the model formats it.

  2. Identify Common Patterns

    • Analyze the generated responses to find common structures:
      • What fields does the model consistently include?
      • What format does it naturally prefer (JSON, function-style, key-value pairs, etc.)?
      • How does it handle error cases?
    • This helps avoid fighting with the model over syntax.

  3. Use the Model’s Preferred Format

    • When you actually need to generate a tool call, you now use the model’s own tendencies rather than forcing an unnatural format.
    • This ensures that:
      • The model generates consistent and correct outputs.
      • You don’t waste time trying to “fix” formatting every time.

  4. Bridge the Gap if Needed

    • If you already have an existing data structure (e.g., an API schema you can’t change), instead of forcing the model to fit that, build an adapter layer.
    • Example:
      • If your model generates JSON but your system expects XML, just build a conversion layer rather than forcing the model to output XML.
    • This keeps the AI flexible while ensuring compatibility.

  5. Model Independence

    • If you later switch AI models, just have the new model generate its own tool call format, then adapt using an abstraction layer.
    • This avoids hardcoding things that might break when you upgrade.

MCP

model context protocol standardizes how the AI application interact with external system

https://e2b.dev/

https://github.com/Shopify/toxiproxy

https://huggingface.co/spaces/hf-audio/open_asr_leaderboard  Open ASR Leaderboard ranks and evaluates speech recognition models on the Hugging Face Hub.

Graph View