Link List :: 2025-01-26

14 minutes read
linklist
links

https://github.com/langgptai/awesome-claude-prompts

https://github.com/lsgrep/chrome-extension-ollama-chat

  • A Chrome extension that adds a sleek sidebar interface for chatting with local LLMs using Ollama, built with React, TypeScript, and Vite.
  • Supports smooth sidebar integration with any webpage
  • Includes chat interface with support for Markdown formatting
  • Features real-time streaming responses
  • Offers clean and modern UI design
  • Allows multiple model support via Ollama
  • Provides keyboard shortcuts for quick access
  • Requires Node.js (v16 or higher), npm, yarn, Chrome browser, and Ollama installed and running locally
  • Clone the repository using git clone <repository-url>
  • Install dependencies with npm install
  • Build the extension with npm run build
  • Load the extension in Chrome by enabling “Developer mode” and loading it from the dist directory
  • Start Ollama with CORS enabled by running OLLAMA_ORIGINS=chrome-extension://* ollama serve
  • Pull a model (if necessary) using ollama pull <model-name>
  • Start the development server with npm run dev
  • The extension will rebuild automatically when changes are made
  • Click the extension icon to toggle the sidebar, select an Ollama model, and start chatting
  • Features React + TypeScript for the UI, Vite for building and development, Chrome Extension Manifest V3, and Ollama API for local LLM integration
  • Utilizes real-time streaming using Server-Sent Events
  • Includes improved sidebar styling and layout, smooth animations, and fixed visibility toggle
  • Adjusted width for better readability
  • Initial release with basic chat functionality and Ollama integration
  • Supports Markdown formatting
  • Licensed under the WTFPL - Do What the Fuck You Want to Public License (see LICENSE file)

https://github.com/KoljaB/RealtimeSTT

A Python library used for speech recognition and transcription.

https://github.com/blinko-space/blinko

  • Blinko is an innovative open-source project designed for individuals who want to quickly capture and organize their fleeting thoughts.
  • Blinko allows users to seamlessly jot down ideas the moment they strike, ensuring that no spark of creativity is lost.
  • AI-Enhanced Note Retrieval :With Blinko’s advanced AI-powered RAG (Retrieval-Augmented Generation), you can quickly search and access your notes using natural language queries, making it effortless to find exactly what you need.
  • Data Ownership :Your privacy matters. All your notes and data are stored securely in your self-hosted environment, ensuring complete control over your information.
  • Efficient and Fast :Capture ideas instantly and store them as plain text for easy access, with full Markdown support for quick formatting and seamless sharing.
  • Lightweight Architecture with Heavy Lifting :Built on Next.js, Blinko offers a sleek, lightweight architecture that delivers robust performance without sacrificing speed or efficiency.
  • Open for Collaboration :As an open-source project, Blinko invites contributions from the community. All code is transparent and available on GitHub, fostering a spirit of collaboration and constant improvement.
  • Install command: curl -s https://raw.githubusercontent.com/blinko-space/blinko/main/install.sh | bash

https://eamag.me/2025/Voice-Cloning

  • Recently a post about generating audiobooks started trending on hn, and some people in the comments wished they could clone their voice and narrate text without sending it off their machine. It’s never been easier!
  • For this example, we only need a mac, uv (modern python package manager), ffmpeg for audio processing and optionally chatgpt for transcribing your voice (but you can do it manually or use mlx-whisper, for example).
  • We will be using F5-TTS-MLX, an open-source speech synthesis implementation of F5 TTS model in Apple Silicon array framework
  • The final result: Compare to the original source video with him. The source quality is very important!
  • Step by step guide:
    • Install ffmpeg anduv using viabrew install ffmpeg uv
    • Create some directory and initialize a uv package with mdiir voiceclone && cd voiceclone && uv init
    • Download a video using yt-dlp like uvx yt-dlp -x —audio-format wav -o out.wav https://www.youtube.com/shorts/S0gEZ72uBWU
    • Convert the audio to a suitable format with ffmpeg -i out.wav -ac 1 -ar 24000 -sample_fmt s16 -t 10 sample.wav
    • Get a reference text for this audio, either manually or by transcribing the audio using ChatGPT/Whisper/Gemini
    • Run the following command: uv run -m f5_tts_mlx.generate --ref-audio sample.wav --ref-text "your desired text" --output gen.wav --text "your desired text"
  • Going beyond:
    • The original implementation has support for multiple languages.
    • The MLX implementation includes a duration predictor specifically for English, which simplifies the creation of natural-sounding audio.

https://github.com/theJayTea/WritingTools

Welcome to Writing Tools, a free and open-source writing assistant. This tool aims to provide users with a distraction-free environment for writing, editing, and proofreading.

Features

  • Distraction-free writing mode
  • Syntax highlighting and code completion
  • Real-time spell checking and grammar suggestions
  • Chat mode (no text selected)
  • Start-on-boot setting
  • Dark mode and plain theme options

Installation

To use Writing Tools, you’ll need to:

  1. Download the repository as a ZIP file.
  2. Extract the contents of the zip file.
  3. Install Python 3.x (version 3.7 or later) on your system.
  4. Run pip install -r requirements.txt in the terminal.

Compiling with PyInstaller

To build Writing Tools as an executable, follow these steps:

  1. Create and activate a virtual environment.
  2. Install the required packages (pip install -r requirements.txt).
  3. Build Writing Tools using python pyinstaller-build-script.py.

MacOS Version (by Aryamirsepasi)

  1. Install Xcode on your system.
  2. Clone the repository: git clone https://github.com/theJayTea/WritingTools.git.
  3. Open the project in Xcode and select the “writing-tools.xcodeproj” file.
  4. Configure the project settings:
    • Deployment Target: macOS 14.0
    • Signing & Capabilities: Add your development team
  5. Build and run Writing Tools using Xcode.

https://github.com/jankrepl/deepdow

  • deepdow is a Python package connecting portfolio optimization and deep learning
  • Its goal is to facilitate research of networks that perform weight allocation in one forward pass
  • It attempts to merge two common steps in portfolio optimization: forecasting and optimization
  • The network is fully differentiable and can be optimized with gradient descent algorithms
  • It’s focused on active trading strategies, finding allocations over some horizon (buy and hold)
  • Transaction costs are not a primary concern
  • A reinforcement learning framework allows for easy reuse of layers in other deep learning applications
  • Layers built on torch and integrate differentiable convex optimization and clustering based portfolio allocation algorithms
  • Multiple dataloading strategies available, including integration with mlflow and tensorboard via callbacks
  • Variety of losses provided, such as sharpe ratio and maximum drawdown
  • Easy to extend and customize, with CPU and GPU support
  • Citing deepdow is required in research using the package or its ideas

https://github.com/shashankvemuri/Finance

  • Welcome! Finance is a collection of 150+ Python for Finance programs for gathering, manipulating, and analyzing stock market data.
  • Our repository is organized into several key sections:
    • Programs to screen stocks based on technical and fundamental analysis
    • Introductory machine learning applications for stock classification and prediction
    • Simulations of trading strategies and portfolio analysis tools
    • Detailed analysis tools for individual stock assessment
    • Tools for collecting stock price action and company data via APIs and web scraping
    • Visual tools for popular technical indicators like Bollinger Bands, RSI, and MACD
  • To get started, clone the repository and install the required dependencies:
  • Detailed instructions on how to use each program can be found within their respective directories.
  • Explore different modules to discover their functionalities.
  • Each script in this collection is stand-alone.
  • Here’s how you can run a sample program:
    • python example_program.py
  • Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are greatly appreciated.
  • This project is licensed under the MIT License.
  • The material in this repository is for educational purposes only and should not be considered professional investment advice.

https://www.qodo.ai/blog/rag-for-large-scale-code-repos/

The article discusses the challenges of implementing a search system (RAG) for massive enterprise codebases and presents a solution that addresses these challenges. Here are some key points:

Challenges

  1. Noise and inefficiency: Searching across all repositories becomes noisy and inefficient as the number of repositories grows.
  2. Lack of standardization: Evaluating the performance of RAG systems is challenging due to the lack of standardized benchmarks.

Solution

  1. Intelligent chunking: The system uses intelligent chunking techniques to break down large codebases into smaller, more manageable pieces (chunks).
  2. Enhanced embeddings: It generates natural language descriptions for each code chunk, which are then embedded alongside the code.
  3. Advanced retrieval techniques: The system performs a two-stage retrieval process, using an LLM to filter and rank results based on relevance.
  4. Scalable architectures: The system is designed to scale with growing repository sizes, using repo-level filtering strategies and “golden repos” (designated repositories that align with best practices).

Key Techniques

  1. LLM-generated descriptions: Natural language descriptions are generated for each code chunk, improving retrieval for natural language queries.
  2. Two-stage retrieval process: The system uses an LLM to filter and rank results based on relevance, reducing noise and improving accuracy.

Evaluation and Benchmarking

  1. Multi-faceted evaluation approach: The system evaluates performance using a combination of automated metrics (relevance scoring, accuracy metrics, efficiency measurements) and real-world usage data from enterprise clients.
  2. Golden repos: Repositories are designated as “golden” based on metadata and high-level content analysis to narrow down the search space.

https://github.com/cuse-dev/cuse

  • An open-source framework for building AI agents that can interact with computers

    • Computer Control: Display, mouse, and keyboard interaction
    • Authentication: Authenticate with credentials
    • File Operations: View, create, and edit files
    • Shell Access: Execute commands and manage processes
    • App Framework: Build custom applications
    • Linux Support: Run via Docker containers

  • Task: Check gmail inbox and send summary to {email}

  • Example: cuse.demo.mp4

  • Install dependencies:

npm install @cusedev/core

https://github.com/regnull/how.sh

how.sh: A Simple Shell Scripting Tool

how.sh is a lightweight shell scripting tool that allows you to write simple scripts without having to learn complex shell commands. It provides a user-friendly interface for executing various tasks, such as creating files, deleting files, sending emails, and more.

Getting Started

To use how.sh, simply run the script in your terminal:

./how.sh

This will open the how.sh menu, where you can choose from various options to execute a task.

Available Commands

Here are some examples of available commands:

  • create: Create a new file or directory with a given name and contents.
  • delete: Delete an existing file or directory with a given name.
  • tell: Display the contents of a file or directory.
  • copy: Copy the contents of one file to another.
  • move: Move a file from one location to another.
  • send_email: Send an email with a given subject and body.
  • generate_random_password: Generate a random password for a user.

https://github.com/jbellis/llmap

  • LLMap is a CLI code search tool designed to solve the problem of finding context for editing code by asking DeepSeek-V3 and DeepSeek-R1 about the relevance of each source file.
  • LLMap performs its analysis in stages: coarse analysis using code skeletons, full source analysis of potentially relevant files, and refining the output to only the most relevant snippets.
  • Only Java and Python files are currently supported by the skeletonization pass, but other languages can be processed with slower full source analysis.
  • LLMap optimizes the problem by using a multi-stage analysis to avoid spending more time than necessary on obviously irrelevant files.
  • The tool caches LLM responses in ~/.cache/llmap to prevent rate limiting issues and reduce reprocessing time.
  • Commandline parameters include –sample, –llm-concurrency, –no-refine, –no-skeletons, and others.
  • Environment variables such as LLMAP_CACHE, LLMAP_ANALYZE_MODEL, and LLMAP_REFINE_MODEL can be set to customize the tool’s behavior.
  • The tool prints the most relevant context found to stdout, and errors are logged to stderr.

https://github.com/kamilstanuch/codebase-digest

This is a large codebase management system that provides various tools and functionality for developers, testers, and project managers. The system appears to be designed to facilitate collaboration, improve code quality, and reduce technical debt.

The codebase itself is written in Python and uses various frameworks such as Flask, Django, and SQLAlchemy. It has a modular structure, with each module serving a specific purpose, such as:

  1. prompt_library: A library of prompts for generating code completion suggestions, refactoring recommendations, and other text-based outputs.
  2. project_library: A collection of project templates, including a basic template for a web application, a mobile app, and more.
  3. analysis_library: A set of tools for analyzing code quality, detecting technical debt, and identifying performance bottlenecks.

Some notable features of the system include:

  1. Code analysis and suggestions: The system can analyze code and provide suggestions for improvement, including refactoring recommendations, bug fixes, and optimization techniques.
  2. Code completion: The prompt_library provides a set of prompts that can be used to generate code completion suggestions, making it easier for developers to write clean, efficient code.
  3. Technical debt estimation: The system can estimate the amount of technical debt present in a codebase, helping project managers and developers prioritize refactoring efforts.
  4. Performance analysis and optimization: The analysis_library provides tools for analyzing performance bottlenecks and suggesting optimizations.

The system is designed to be extensible, with a modular structure that allows new modules and features to be added as needed. It also includes a comprehensive set of documentation and tutorials to help users get started.

https://github.com/sauravpanda/BrowserAI

  • Features:

    • 100% Private: All processing happens locally in your browser
    • WebGPU Accelerated: Near-native performance
    • Zero Server Costs: No complex infrastructure needed
    • Offline Capable: Works without internet after initial download
    • Developer Friendly: Simple sdk with multiple engine support
    • Production Ready: Pre-optimized popular models

  • Use Cases:

    • Web developers building AI-powered applications
    • Companies needing privacy-conscious AI solutions
    • Researchers experimenting with browser-based AI
    • Hobbyists exploring AI without infrastructure overhead

  • Models:

    • Llama-3.2-1b-Instruct
    • SmolLM2-135M-Instruct
    • SmolLM2-360M-Instruct
    • SmolLM2-1.7B-Instruct
    • Qwen-0.5B-Instruct
    • Gemma-2B-IT
    • TinyLlama-1.1B-Chat-v0.4
    • Phi-3.5-mini-instruct
    • Qwen2.5-1.5B-Instruct
    • Whisper-tiny-en (Speech Recognition)
    • Kokoro-TTS (Text-to-Speech)

https://idinsight.github.io/tech-blog/blog/enhancing_maternal_healthcare/

This text describes a research project on using artificial intelligence (AI) to improve maternal health support in developing regions. The project, led by IDinsight, MomConnect, and Google.org, aims to leverage AI to identify and prioritize urgent messages, thereby improving the responsiveness and effectiveness of maternal healthcare services.

Here are some key points from the text:

  1. Project overview: The project uses advanced technology to integrate community-based healthcare with AI-powered solutions.
  2. Objective: The main objective is to improve the responsiveness and effectiveness of maternal healthcare services by leveraging AI to identify and prioritize urgent messages.
  3. Methodology: The researchers fine-tuned a pre-trained language model (Gemma-2) using a small, high-quality dataset of synthetic user messages, ensuring that each message aligns with its selected urgency rule with high confidence.
  4. Results: The researchers benchmarked their fine-tuned model against the GPT-family of models from OpenAI and achieved competitive performance, outperforming the base Gemma-2 2-billion instruction model.
  5. Future directions: To improve upon the results, the authors suggest three avenues for future research:
    • Increasing the size and diversity of the training dataset to reduce overfitting.
    • Incorporating ambiguous messages into the preference optimization process to improve handling of uncertain cases.
    • Fine-tuning a larger, more advanced language model (Gemma-2 9-billion) to tap into its potential for emergent capabilities.
  6. Benefits: The project has the potential to set a new standard for maternal health support, providing a scalable and private solution to address challenges in developing regions.

The text concludes by acknowledging Google.org’s funding and providing valuable insights throughout the process, and invites readers to explore the publicly available dataset and model to further collaborate on advancing maternal healthcare globally.

https://aclanthology.org/2024.nllp-1.2.pdf

Summarizing Long Regulatory Documents with a Multi-Step Pipeline.

https://github.com/FareedKhan-dev/ai-debugger

  • An LLM-based code debugger that automatically finds and fixes errors in Python code.
  • Analyzes code, suggests fixes, and searches online for solutions when needed.
  • Target audience: developers looking for an AI-powered code debugging tool and those interested in learning about LLMs for code analysis.

https://github.com/ggml-org/llama.vscode

  • Ring context with chunks from open and edited files and yanked text
  • Supports very large contexts even on low-end hardware via smart context reuse
  • Display performance stats

https://github.com/Gurubase/gurubase

  • Advanced LLM-based question answering, including instant evaluation mechanism to minimize hallucination as much as possible
  • Retrieval Augmented Generation for accurate, context-aware responses
  • Multiple Data Sources: Add web pages, PDFs, videos, and GitHub repositories as data sources for your Guru.
  • Easy Integration: Embeddable widget for your website. Discord and Slack Bots coming soon
  • Custom Gurus: Create specialized AI assistants for specific topics
  • Real-time Updates: Keep the data sources up to date by reindexing them with one click
  • ⛬ Binge: Visualize your learning path while talking with a Guru.
  • 🛠 Self-hosted Option: Full control over your deployment. Install the entire system on your servers
  • Architecture:
    • Indexing: Processes and chunks data sources
    • Embedding: Converts text into vector representations
    • Storage: Stores vectors in Milvus for efficient similarity search
    • Retrieval: Finds relevant context when questions are asked
    • Generation: Uses LLMs to generate accurate answers based on retrieved context
    • Evaluation: Evaluates the contexts to prevent hallucinations

https://github.com/popey/twitter-defollower

  • A Python script to automatically remove followers from your Twitter/X account.
  • The script currently does not unfollow people that you follow, but removes people who follow you.
  • Logs into your X account and navigates to your followers page.
  • Removes 10 followers per batch with automatic page refreshes between batches.
  • Continues until stopped or no more followers found.
  • Tested on macOS and Ubuntu 24.04.
  • Uses human-like delays and interactions to avoid triggering anti-automation measures.
  • May still detect automation and request additional verification.
  • Use responsibly and in accordance with X’s terms of service.
  • Requires Python 3.10 or higher, Chrome or Chromium browser, uv (virtual environment) or any other virtual-env system.
  • Clone this repository: git clone https://github.com/popey/twitter-defollower
  • Create a virtual environment and install dependencies using uv venv and source .venv/bin/activate.
  • Edit the script to add your credentials: username = "your_username", password = "your_password", and email_or_phone = "your_email_or_phone".
  • Run the script: python twitter-defollower.py
  • No additional verification required for most users, but may be needed if X requests it.
  • The script does not stop people re-following you, use Twitter profile security settings instead.
  • The script may break or require patches if X changes its flow or adds bot detection measures.
  • If the account is blocked or suspended, it will be blocked or suspended.

https://www.reddit.com/r/LocalLLaMA/comments/1i81ev6/deepseek_added_recommandations_for_r1_local_use/

  • DeepSeek added recommandations for R1 local use to model card https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B#usage-recommendations
  • We recommend adhering to the following configurations when utilizing the DeepSeek-R1 series models, including benchmarking, to achieve the expected performance:
    1. Set the temperature within the range of 0.5-0.7 (0.6 is recommended) to prevent endless repetitions or incoherent outputs.
    1. Avoid adding a system prompt; all instructions should be contained within the user prompt.
    1. For mathematical problems, it is advisable to include a directive in your prompt such as: “Please reason step by step, and put your final answer within \boxed{}.”
    1. When evaluating model performance, it is recommended to conduct multiple tests and average the results.