Link List :: 2024-12-31

December 31, 2024 37 minutes read

links

https://github.com/sturdy-dev/semantic-code-search

* 🔍 Overview 
*  • 🔧 Installation 
*   pip3 install semantic-code-search
*  • 💻 Usage 
*   sem 'my query'

https://github.com/wangxj03/ai-cookbook/tree/main

* wangxj03/ai-cookbook

https://github.com/AndrewNgo-ini/agentic_rag

* # Project Overview
* A fully custom chatbot built with Agentic RAG (Retrieval-Augmented Generation), combining OpenAI models with a local knowledge base.
* Lightweight, dependency-free frontend and streamlined FastAPI backend for complete control and simplicity.

* # Technical Details
* Pure HTML/CSS/JavaScript frontend with no external dependencies
* FastAPI backend with OpenAI integration
* Agentic RAG implementation:
  * Context retrieval using embeddings and cosine similarity
  * Step-by-step reasoning with Chain of Thought
  * Function calling for dynamic context retrieval
  * Comprehensive error handling and logging
  * Type-safe implementation with Python type hints
  * Configurable through environment variables

https://github.com/duriantaco/treeline

pip install treeline 

from treeline import treeline 
print(treeline("/path/to/directory")) 
treeline("/path/to/directory", create_md=True) 

from treeline.dependency_analyzer import ModuleDependencyAnalyzer 
from treeline.diff_visualizer import DiffVisualizer 
from pathlib import Path 

analyzer = ModuleDependencyAnalyzer() 
analyzer.analyze_directory(Path(".")) 
with open("dependencies.html", "w", encoding="utf-8") as f: 
    f.write(analyzer.generate_html_visualization()) 
    visualizer = DiffVisualizer() 
    diff_html = visualizer.generate_structural_diff("HEAD^", "HEAD")

https://www.macrohistory.net/database/

This is a list of contributors to the “History of Economic Thought” dataset, which appears to be an open-access project aimed at providing historical data on economic thought. Here are some observations and insights from reviewing this list:

Organization: The list is organized alphabetically by country, with each entry including the name(s) of contributor(s), affiliation(s), and date(s).

Contributor diversity: The list includes individuals from over 40 countries, representing a wide range of institutions and affiliations.

Research assistants and doctoral students: Many contributors are listed as research assistants or doctoral students, suggesting that this project is heavily reliant on graduate students and postdoctoral researchers to gather and process data.

Academic background: The majority of contributors appear to have academic backgrounds in economics, finance, or related fields.

Geographic representation: The list is fairly evenly distributed across different regions of the world, with some countries having a relatively larger number of contributors than others.

Collaboration: Many contributors are listed multiple times, indicating that this project may involve collaborative efforts between researchers and institutions.

Some potential follow-up questions or observations based on this list include:

Data quality and accuracy: How can we ensure the quality and accuracy of data provided by researchers who are often students or postdoctoral researchers?
Representation and bias: Are there any concerns about underrepresentation or overrepresentation of certain groups, regions, or ideologies in the dataset?
Methodological consistency: How consistent are the methods used to gather and process data across different countries and affiliations?

Overall, this list provides a fascinating glimpse into the diversity of contributors to the “History of Economic Thought” project, highlighting the importance of collaboration, international cooperation, and diverse perspectives in shaping our understanding of economic thought.

https://github.com/abuiles/ramon

- # Introduction
  * Ramon is a good AI assistant that helps manage, prioritize, and streamline tasks.
  * It tracks deadlines, facilitates collaborations, and integrates with systems like JIRA to automate workflows.

https://simonwillison.net/2024/Dec/11/gemini-2/

This article discusses the latest updates to Google’s Gemini AI model, specifically Gemini 2.0 Flash. The author is excited about the new features and capabilities of this version, which includes:

Improved spatial understanding: The model can now return bounding boxes around objects in images, even for complex photographs.
Code execution: The model can write and execute Python code, running it and considering the result as part of its response.
Streaming API: A new two-way stream allows for real-time audio and video input, with text and audio output in return.

The author is impressed by these features and believes they are “straight out of science fiction.” They also note that OpenAI’s WebSocket streaming API was released recently, but it only handles audio and is currently expensive to use.

Some things to look forward to include:

Multi-modal image output: Models will be able to do fine-grained image editing, which has been a long-term goal for diffusion-based image models.
Native audio output: Gemini 2.0 Flash will be able to produce high-quality audio output with different voices, intonations, languages, and accents.

The author also shares some thoughts on the potential applications of these features, such as:

Conversational AI: Being able to have an audio conversation with a capable LLM about things that it can “see” through your camera is a powerful tool.
Advertising: The ability to serve targeted ads based on voice recognition and other forms of surveillance raises concerns.

https://ai.google.dev/showcase/tldraw

* Gemini Powers tldraw's "Natural Language Computing" Experience
* Unlocking Natural Language Interactions with the Gemini API
* The Gemini API empowers developers to seamlessly integrate advanced AI capabilities into their applications, unlocking new possibilities for user experience and functionality.
* This post highlights how tldraw leverages Gemini to build a revolutionary "natural language computing" experience within their new project, computer.
* Demonstrates the speed and ease with which startups can integrate powerful AI using the Gemini API and tldraw’s canvas SDK.
* The tldraw team is launching computer with Gemini 1.5 Flash soon (join the waitlist) and is currently prototyping with Gemini 2.0 Flash for future iterations.
* Tldraw uses the Gemini API to bring conversational AI to visual programming, allowing users to generate content and process information using natural language.
* Opens up exciting opportunities for more intuitive and efficient user experience around AI, pushing the boundaries of visual communication.
* The Vision Behind Computer
* Striving to make diagramming accessible and intuitive, tldraw envisioned a more natural way for users to interact with their canvas.
* Founder Steve Ruiz sought to leverage the power of tldraw’s infinite canvas SDK to create a dynamic environment for working with generative AI.
* This vision led to the development of computer, an experimental application where users create workflows from blocks of text, images, and instructions.
* When run, information flows from one component to the next, creating powerful processes that branch, loop, and iterate to produce outputs.
* Building with Gemini 2.0: A Deep Dive into Computer
* Tldraw’s computer is built upon a network of interconnected “components” representing elements on the canvas (text boxes, images, audio clips, etc.).
* These components are linked by arrows, visualizing the flow of data and transformations.
* Each component has associated "procedures"—sets of instructions executed based on inputs from connected components.
* A component can accept data from any number of other components and pass its output data to many other components—including itself!
* This component-based architecture, combined with the power and speed of Gemini 2.0 Flash, allows for a fast and flexible system capable of handling diverse tasks.
* Lightning-Fast Procedure Execution: Gemini 2.0 Flash executes procedures rapidly, enabling rapid generation of scripts and outputs.
* Lots of Context, Many Modes: The maximalist bent in tldraw’s computer called for speed, capacity, and capability, making use of Gemini 2.0 Flash’s large context window.
* Structured Data: The flow of data between components relies on adherence to a single schema, ensuring efficient execution and preventing stalls.
* Dynamic Procedure Generation: Gemini 2.0 Flash can generate procedures dynamically, unlocking tremendous potential for innovative user experiences and streamlined workflows.
* A Quick Win for Innovation
* Tldraw’s quick implementation of computer highlights Gemini’s value proposition for startups: rapid prototyping, enhanced user experience through intuitive natural language interfaces, and efficient structured data handling.
* Empower Your Application with the Gemini API
* The Gemini API offers powerful models like Gemini 1.5 Pro, Gemini 1.5 Flash, and now Gemini 2.0 Flash as an experimental preview model to bring innovative AI features to your application.
* Explore the Gemini API documentation and empower your users with AI for creative professionals, developers, and teams of all kinds.

https://ollama.com/blog/structured-outputs

- Structured outputs are available in Ollama, allowing models' outputs to be constrained to a specific format defined by a JSON schema.
- The Ollama Python and JavaScript libraries have been updated to support structured outputs.

- Use cases include:
    - Parsing data from documents
    - Extracting data from images
    - Structuring all language model responses
    - More reliability and consistency than JSON mode

- Tips for reliable use of structured outputs include:
    - Using Pydantic (Python) or Zod (JavaScript) to define the schema for the response
    - Adding “return as JSON” to the prompt to help the model understand the request
    - Setting the temperature to 0 for more deterministic output

- Future plans include:
    - Exposing logits for controlled generation
    - Performance and accuracy improvements for structured outputs
    - GPU acceleration for sampling
    - Additional format support beyond JSON schema

https://github.com/ai-christianson/RA.Aid

RA.Aid is a Python-based tool designed to aid in the development and research process. It provides an interactive workflow for tasks such as code generation, documentation creation, and system operation management.

Key Features:

Three-stage architecture: RA.Aid implements a three-stage architecture: Research, Planning, and Implementation. This allows users to gather information, develop detailed implementation plans, and execute planned tasks efficiently.
Integration with various tools: RA.Aid is integrated with several third-party libraries, including LangChain, Tavily, python-Levenshtein, fuzzywuzzy, pathspec, pytest, and pytest-timeout. These integrations enable users to leverage the strengths of each tool for enhanced development and research capabilities.
Interactive workflow: RA.Aid features an interactive console that handles user interaction and console output formatting.

https://simonwillison.net/2024/Dec/14/improve-your-writing/

* 3 shell scripts to improve writing:
	+ Abuse of passive voice
	+ Weasel words
	+ Lexical illusions (repeated word within a line break)
* The author, Matt Might, created these scripts to help with Ph.D. student writing advice
* He replaced himself with a script to implement the rules and created a web tool at tools.simonwillison.net/writing-style
* Tools are available for HTML+JavaScript artifact implementation
* Source code and commit history are publicly available
* Recent articles include:
	+ AI/LLM predictions
	+ Weeknotes: Starting 2025 slow
	+ Rebutting the microphone ad spy theory

https://github.com/SjorsLockhorst/sem-art-search

* This is the repository where the code for artexplorer.ai lives, a semantic search for artworks. To know more about how it's built, read our blogpost.

https://www.york.ac.uk/news-and-events/news/2024/research/school-smartphone-ban-better-sleep/

* Swiped: The School that Banned Smartphones is based at The Stanway School in Colchester and challenged a group of Year 8 pupils to give up their smartphones for 21 days.
* The experiment, led by Professor Lisa Henderson and Dr Emma Sullivan from the University, saw pupils undergo a series of tests with experts monitoring their behavioural changes throughout the period.
* Pupils experienced notable improvements in sleep, falling asleep 20 minutes faster on average and getting an extra hour of rest each night.
* Mood boost: Children reported going to bed 50 minutes earlier and experiencing a 17% reduction in feelings related to depression and a 18% reduction in anxiety.
* Positive impact: Professor Lisa Henderson said the results showed a smartphone ban could have a positive impact on sleep, mood and wellbeing, but cognitive ability improvements might take longer.
* Policy decisions: Dr Emma Sullivan said the results are crucial for informed conversations about the impact of smartphones on young people and may influence government policy decisions in the UK and other countries.

https://old.reddit.com/r/LocalLLaMA/comments/1hf7jd2/everyone_share_their_favorite_chain_of_thought/

* Everyone share their favorite chain of thought prompts!
* Discussion about sharing favorite prompts for self.LocalLLaMA

https://old.reddit.com/r/LocalLLaMA/comments/1hfdx7k/github_microsoftmarkitdown_python_tool_for/

* GitHub - microsoft/markitdown: Python tool for converting files and office documents to Markdown

https://til.simonwillison.net/llms/streaming-llm-apis

The provided Python code uses the httpx library to send a POST request to the OpenAI API with a JSON payload. The aconnect_sse package is used to create an event source from the response, which allows for real-time streaming of the API’s responses.

To log the output of the stream to the console using this code, you can use the asyncio.run() function to run the main() function, which calls stream_openai_response(prompt) with a given prompt. Here is an updated version of the Python code that includes logging:

import os
import json
import asyncio
import httpx
from httpx_sse import aconnect_sse

async def stream_openai_response(prompt):
    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        raise ValueError("OPENAI_API_KEY not found in environment variables")

    url = "https://api.openai.com/v1/chat/completions"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }

    data = {
        "model": "gpt-4-turbo-preview",
        "messages": [{"role": "user", "content": prompt}],
        "stream": True,
        "stream_options": {
            "include_usage": True
        }
    }

    async with httpx.AsyncClient() as client:
        async with aconnect_sse(client, "POST", url, json=data, headers=headers) as event_source:
            async for sse in event_source.aiter_sse():
                if sse.event == "error":
                    print(f"Error: {sse.data}")
                elif sse.event == "usage":
                    usage = json.loads(sse.data)
                    print(f"Usage: {usage}")
                else:
                    try:
                        chunk = json.loads(sse.data)
                        if chunk['choices'][0]['finish_reason'] is not None:
                            break
                        content = chunk['choices'][0]['delta'].get('content', '')
                        print(content, end='', flush=True)
                    except json.JSONDecodeError:
                        print(f"Failed to parse JSON: {sse.data}")

async def main():
    prompt = "Tell me a joke"
    await stream_openai_response(prompt)

if __name__ == "__main__":
    asyncio.run(main())

This updated code logs the response data to the console as it is received from the API, using print() statements with the flush=True argument to ensure that the output is displayed immediately.

Note that this code assumes that you have the OpenAI API key stored in an environment variable named OPENAI_API_KEY. You should replace this with your actual API key.

https://github.com/RafalWilinski/mcp-apple-notes

* 🔍 A Model Context Protocol (MCP) server for semantic search and RAG over Apple Notes
* 📝 Full-text search capabilities using all-MiniLM-L6-v2 on-device embeddings model
* 🤖 MCP-compatible server for AI assistant integration
* 🍎 Native Apple Notes integration via JXA
* 🏃♂️ Fully local execution - no API keys needed

https://github.com/madroidmaq/mlx-omni-server

* # Overview of MLX Omni Server
*  * Built on Apple's MLX framework for local inference on Apple Silicon chips
*  * Implements OpenAI-compatible API endpoints
*
* # Features
*  * Audio Processing (TTS & STT)
*  * Chat Completion
*  * Image Generation
*  * High Performance with hardware acceleration
*  * Privacy-First: All processing happens locally on your machine
*  * SDK Support for OpenAI and other compatible clients
*
* # API Endpoints
*  * Chat completions: /v1/chat/completions
*  * Chat: /v1/chat
*  * Tools, Function Calling: /v1/tools
*  * Structured Output: /v1/structured_output
*  * LogProbs: /v1/logprobs
*  * Vision: /v1/vision
*  * Audio:
*   * Text-to-Speech: /v1/audio/speech
*   * Speech-to-Text: /v1/audio/transcriptions
*   * Models: /v1/models
*   * List models: /v1/models/{model}
*   * Retrieve or Delete model: /v1/models/{model}
*   * Images: /v1/images/generations
*
* # Examples
*  * Text-to-Speech Example
*  * Speech-to-Text Example
*  * Chat Completion Example
*  * Image Generation Example

https://github.com/Lobelia-Earth/url-state-codecs

* Codecs for encoding arbitrary state trees into URL parameters and back again.
* A codec is a portmanteau of "encoder" and "decoder", traditionally used in data streams, but now applied to encoding/disencoding discrete JavaScript application states to/from URL parameters.
* Focus on core challenges:
    - Encoding complex objects
    - Omitting values unchanged from their defaults
    - Compressing them as URL-safe strings
    - Type safety
    - Robust and helpful error handling
    - Avoid tight coupling with state management libraries/architectures/reactivity models
    - Modularizing value codecs for importability
    - Minimizing runtime dependencies
    - Versioning build metadata
* Design an API that results in easy-to-read code.
* Example usage:
    - Defining default and new states
    - Encoding changes as URL parameters
    - Decoding complete state tree with default values supplied where corresponding URL parameters are omitted
* Integration with state management libraries:
    - Using a subscriber to synchronize updates to the application state with URL parameters
    - Merging decoded state into current application state
* Additional features:
    - Encoding and decoding deeply nested values
    - ISO 8601 dates
    - Booleans
    - Entire objects as base64 strings
    - NaN handling
    - Nullable values
* Guidelines for contributing:
    - File an issue before opening a PR
    - Discuss significant changes with maintainers first
    - Maintain high level of type safety
    - Ensure unit tests pass and new code is reasonably covered by tests

https://github.com/mmiscool/aiCoder

# aiCoder features and functionality

* Simplify development by automating repetitive coding tasks
* Improve code quality with intelligent suggestions
* Focus on higher-level design and problem-solving
* Seamlessly integrate new features and improvements into your existing codebase
* Save time by automating repetitive coding tasks
* Improve code quality with intelligent suggestions
* Focus on higher-level design and problem-solving
* Run aiCoder or just thea command in your project's directory
* Use New Plan Chat to discuss and define your project requirements, then save the plan

# UI and workflow

* Use New Chat to interactively modify a selected file
* Begin by describing your project goals
* Clicking on a method passes it into a new chat, allowing you to modify or implement it
* Displays all detected methods - Green methods: Implemented methods with code - Red methods: Stubs that need implementation
* Add skeleton of all existing classes and methods to the top of the file

# Supported LLM providers and models

* OpenAI's gpt-4o-mini orgpt-4o models work well
* Anthropics's claude-3-5-haiku works fine, but is more expensive
* Groq is less tested and has a smaller context window, not recommended for use
* Ollama runs locally but may be slower, with the granite3.1-dense model working well enough
* GoogleAI using the free gemini-1.5-flash seems to work on par with OpenAI gpt-4o-mini

# Features and implementation

* Implemented:
	+ Automatic merging of multiple class/function definitions into a single source structure
	+ Ability to prompt for modifications to a single JS file
	+ Automatic backups before modification
	+ Code snippet extraction from LLM responses and a workflow to accept/reject on a per-snippet basis
	+ Custom prompt manager for reusable prompts
	+ Support for various LLM providers
* To Do: Support multiple files simultaneously, allow the LLM to suggest adding NPM packages, add support for HTML, CSS, and MD files by parsing them to ASTs and merging changes, preserve comments during merges

https://github.com/Grigorij-Dudnik/Clean-Coder-AI

* Clean Coder is an AI Scrum Master and Developer that delegates planning, managing, and coding tasks to AI agents.
* Agents create tasks in Todoist, write code, and test it, reducing project effort and stress.
* Clone repository `git clone https://github.com/GregorD1A1/Clean-Coder-AI`
* Navigate to project directory and install dependencies `cd Clean-Coder-AI && pip install -r requirements.txt`
* Run the application `python single_task_coder.py` or follow detailed instructions in documentation.
* Deploy with Docker for a seamless experience.
* Features:
  * Get project supervision from Manager agent with Todoist-integrated tasks
  * Watch tasks executed one by one by Programming agents
  * Frontend feedback feature allows AI to see its creations
  * Automatic file linting and log checking for self-debugging
  * File Researcher agent with RAG tool for efficient searching
  * Sensitive files protection from AI access
* Report bugs or propose features on Discord
* Join the Clean Coder contributors community for endless glory

https://github.com/mthomason/mbot

* mbot is an open-source starter project for building AI-powered chatbot applications combining Svelte and FastAPI, with Firebase authentication and OpenAI API integration.
* Designed for:
  * AI startup enthusiasts
  * Developers exploring Svelte and FastAPI
  * Hobbyists experimenting with OpenAI's GPT models
* Features include modern Frontend built with SvelteKit and a Secure Authentication system using Firebase.
* To get started, install from Node.js or Python, create a Firebase project and obtain an OpenAI API key.
* Project structure includes:
  * frontend: SvelteKit app for UI
  * backend: FastAPI app for APIs
  * electron (optional): Electron app integration
  * docs: Documentation files
* Create a .env file with environment variables, including:
  * GOOGLE_PROJECT_ID_MBOT: Firebase project ID
  * OPENAI_API_KEY_MBOT: OpenAI API key
* Use the provided VSCode debug configuration to start debugging.
* Contributions are welcome and must follow specific guidelines.
* Project is licensed under the MIT License.

https://github.com/Dicklesworthstone/your-source-to-prompt.html

* Your Source to Prompt is a single .html file that runs entirely in your browser, with no external dependencies or services.
* It's Local and Secure: No code leaves your machine.
* No Installation Hassles: Just open the .html file in any modern browser.
* Works with Any Folder: Not limited to Git repos.
* Optimized for Repeated Use: Save and load presets of file selections and settings.
* Fully Local & Secure: Uses client-side libraries like Terser for JS/TS minification, csso for CSS, and html-minifier-terser for HTML.
* Requires only a recent Chromium-based browser.
* No dependencies or package managers.
* Use with Any Folder or Repo: Perfect for private codebases or just a random set of files you want to show the LLM.
* Presets to Save Time: Store your favorite file selections and reload them instantly in localStorage or export/import as JSON.
* Efficient File Selection:
    * String-based filtering to quickly find files.
    * Convenient mass selection (e.g., “Select all React files”).
    * Toggle all text files with one click.
* Context Size Awareness: A tally of total size and lines is always visible, with warnings if you’re likely to exceed context windows.
* Hierarchical Structure Preview: Automatically includes a tree-like structure showing file sizes and line counts before the code listings.
* Minification to Save Space: Optionally minify JS, CSS, HTML, JSON, and even trim other text files for maximum context efficiency.
* Tally: The total selected size and line count appear in the top-right corner. Heed the warnings if any appear.
* Save a Preset: If you want to reuse these selections and settings, enter a name and click "Save Preset."
* Combine Files: Click "Combine Selected Files" to generate a single text output containing your preamble, goal, hierarchical summary of selected files, and each file preceded by a header line with the filename.
* Copy or Download the Result: Use the provided buttons to copy the combined text to your clipboard or download it as a.txt file.
* Scenario examples and use cases are available in the README file.

https://github.com/RooVetGit/Roo-Cline

Here’s an overview of the Cline extension:

What is Cline? Cline is a browser extension that uses natural language processing and machine learning to automate tasks for developers. It provides features such as file editing, API calls, and web interactions.

Key Features

File Editing: Cline can create and edit files directly in the editor.
API Calls: Cline supports various APIs, including OpenRouter, Anthropic, Glama, OpenAI, Google Gemini, AWS Bedrock, Azure, and GCP Vertex.
Web Interactions: Cline can launch a browser, click elements, type text, and scroll.
Custom Tools: Cline can create and install custom tools using the Model Context Protocol.

How to Use Cline

Open the extension in VSCode by pressing F5 or running code cline.
Use the shortcut CMD/CTRL + Shift + P to open the command palette and type “Cline: Open In New Tab” to open the extension as a tab in your editor.
Ask Cline questions, such as “test the app” or “add a tool that fetches Jira tickets”.

Technical Details

API Providers: Cline supports various API providers, including OpenRouter, Anthropic, Glama, and OpenAI.
Model Context Protocol: Cline uses the Model Context Protocol to extend its capabilities through custom tools.
VSCode Integration: The extension integrates with VSCode using the webview-gui.

Getting Involved

Contribute to the project by exploring open issues or checking the feature request board.
Join the Discord community to share ideas and connect with other contributors.
Check out the careers page for information on joining the team.

https://github.com/CITIZENDOT/SportsBettingArbitrage

* Arbitrage betting involves locking in a win or avoiding a loss by betting on all possible outcomes of an event with different bookmakers, taking advantage of differences in odds.
* Guaranteed profit isn't always possible, but avoiding losses is.
* An example:
  * Betting $1 on Team A (SportsBet) yields $1.9 if Team A wins ($0.9 net profit).
  * Betting $1 on Team B (SportsBet) yields $1.8 if Team B wins ($0.8 net profit).
  * Betting on both teams results in a loss.
* Adding a second bookmaker:
  * Book keeper 1: Team A 1.9, Team B 1.8
  * Book keeper 2: Team A 1.4, Team B 2.5
  * Arbitrage betting $6 on Team A (Book 1) and $4 on Team B (Book 2).
* The script helps find arbitrage opportunities and calculates how much to bet.
* Inputs:
  * Odds for all outcomes
  * Optional bookmaker names (default assigned)
* Covers all outcomes for all bookmakers in the input.
* Sets capital (default is $50, can be changed by tweaking MAX_CAPITAL variable).
* Calculates zero-risk bets with different stakes and winnings.

https://github.com/microsoft/promptflow

* # Welcome to Prompt Flow
* ## Overview
+ A suite of development tools for LLM-based AI applications
+ Streamlines the end-to-end development cycle from ideation to production deployment and monitoring
* ## Key Features
+ Create and iteratively develop flow
+ Debug and iterate flows with ease
+ Evaluate flow quality and performance
+ Integrate testing and evaluation into CI/CD system
+ Deploy to serving platform or integrate into app code base

https://github.com/evoluteur/healing-frequencies

* Simple web page to play the frequencies of various sets of healing tuning forks: Solfeggio, Organs, Mineral nutrients, Ohm, Chakras, Cosmic Octave, Otto, Nikola Tesla 3-6-9, DNA nucleotides, Angels... or custom.
* Advocates of tuning fork therapy report a wide range of benefits, including:
+ Stress Reduction
+ Pain Relief
+ Improved Mental Clarity
+ Emotional Healing

https://dylanhuang.com/blog/closing-my-startup/

* Konfig was a developer tools startup focused on making API integrations easier
* We started in late 2022 with the mission of simplifying how developers work with APIs by providing better tooling around SDK generation, documentation, and testing
* Our main product was an SDK Generator that could take any OpenAPI specification and generate high-quality client libraries in multiple programming languages
* We expanded this with additional tools for API documentation and interactive API testing environments
* We gained some traction with some startups, but weren't able to build a hyper-growth business due to difficulties in getting customers to sign contracts and price points being too low
* We pivoted into a vertical B2B SaaS AI product, but didn't find enough traction to make it successful
* Despite the outcome, we're proud of the technology we built and believe our work could be helpful for others
* We're open-sourcing our entire codebase on public GitHub repo
* The codebase is being released exactly as it was when we shut down—no cleanup, no polishing, no modifications
* In the past 3 years, we built 4 main products and lots of miscellaneous things
* Lots of miscellaneous things include render.yaml
* I want to express my deepest gratitude to everyone who supported us on this journey
* Investors who believed in our vision and backed us financially are thanked
* Customers who trusted us with their business and provided invaluable feedback are thanked
* Teammates Eddie and Anh-Tuan are thanked for their dedication, hard work, and partnership through all the ups and downs
* Looking back on the startup journey, there are no regrets about leaving a job to pursue it full-time
* The experience has been transformative and taught more than success ever could
* As for what's next, I'm excited to explore new opportunities, see where the job market thinks I fit, and continue learning and growing
* Maybe someday I'll take another shot at building something of my own
* This experience has been invaluable, and I'm grateful for everyone involved

https://www.aisnakeoil.com/p/is-ai-progress-slowing-down

This text appears to be an analysis and critique of the current state of artificial intelligence (AI) research and development, particularly in the area of large language models (LLMs). The author argues that the focus on scaling up model size and computing power has led to a misleading narrative about the progress of AI, and that this approach is unlikely to lead to Artificial General Intelligence (AGI).

Here are some key points made by the author:

Scaling is not the only factor in AI progress: The author argues that emergent capabilities based solely on scaling are largely a myth, and that true progress in AI requires understanding the underlying mechanisms and modeling more complex problems.
Human intervention is not a substitute for genuine progress: The author notes that relying on human intervention (e.g., large teams of poorly paid science students) to compensate for shortcomings is not a viable path toward AGI.
The focus on scaling has led to overemphasis on trivial progress: The author argues that the focus on scaling up model size and computing power has led to an overemphasis on trivial progress, rather than addressing more significant challenges in AI research.
Regulation based on arbitrary training compute thresholds is problematic: The author notes that relying on arbitrary thresholds for regulating AI research (e.g., based on computing power) is problematic and unfair to small companies, startups, and academic researchers.
The future of AI depends on a broader understanding of the field: The author argues that the future of AI requires a more nuanced understanding of the field, including the development of new models, algorithms, and techniques for addressing complex problems.

Some of the key points made by critics of the current state of AI research include:

Lack of transparency and accountability: Some critics argue that there is a lack of transparency and accountability in AI research, particularly with regards to the use of computing resources.
Overemphasis on metrics: The author notes that many researchers focus too heavily on metrics such as accuracy and F1-score, rather than considering more nuanced measures of success (e.g., safety, interpretability).
Insufficient consideration of downstream impacts: Some critics argue that AI research often neglects the potential downstream impacts of AI systems on society.

Overall, this text presents a critical perspective on the current state of AI research and development, highlighting the need for a more nuanced understanding of the field and a broader approach to addressing complex problems.

https://systematicindividualinvestor.com/2024/12/17/pyramiding-profits/

The article provides an overview of a risk-managed trading strategy that aims to participate in strong trends with outsized position sizes while minimizing regret if the trend fizzes out prematurely. The key elements of this strategy include:

Tight stop losses: Using tight stop losses to limit potential losses to around 1% of capital or less.
Entry setup with an edge: Identifying entry points with a clear edge, such as a strong trend or a well-defined technical setup.
Laser-focused position sizing: Using large position sizes to capture outsized profits while minimizing risk.
Risk management as the secret sauce: Recognizing that risk management is the key to making many momentum-based trading styles successful.

The article also provides an example of how this strategy can be implemented in practice, using a hypothetical trade involving Bitcoin. The trade involves:

Multiple entries: Entering multiple positions at different levels, with each entry having a smaller stop loss than the previous one.
Trailing stops: Trailing stops to lock in profits and limit potential losses.
Position sizing: Using large position sizes to capture outsized profits while minimizing risk.

The article concludes that this strategy is well-suited for investors who want to participate in strong trends with outsized returns, but are willing to take on some level of risk. It also notes that the key to success lies in managing risk effectively and being prepared to adapt to changing market conditions.

Overall, the article provides a clear and concise overview of a risk-managed trading strategy that aims to capture outsized profits while minimizing regret.

https://github.com/superlinear-ai/raglite

Ragtime is a Python library for building chatbots. It provides a simple and efficient way to create conversational interfaces with natural language processing (NLP) capabilities.

https://github.com/LoSinCos/movie-iris

* The Movie Iris
  * Project started during quarantine, inspired by r/dataisbeautiful on Reddit
  * Take movie frames, compress to core colors, visualize color schemes
  * Learn image processing while creating artistic visualization
  * Share with friends and family

Script Parameters:
  * Height of final barcode
  * Video name
  * Video filepath
  * Frame count to capture

Script Steps:
  * Create local folder for outputs
  * Divide total frames by desired frame count, skip frames accordingly
  * Increase contrast in each frame
  * Resize frames multiple times to reach desired size (1x1000)
  * Merge frames into a barcode image
  * Run linear_to_circular.ipynb file

https://github.com/jakubsuchy/flights-above-me

* Displays a flight directly above you in a fancy display.
* Inspired by https://github.com/smartbutnot/flightportal but uses just Javascript + Browser.
* Uses flightradar24 free API + corsproxy.io.
* Has basic PWA support for iOS.
* Requires CORS proxy (https://corsproxy.io) due to flightradar24's CORS headers.
* Paid version of CORS proxy available for $3/mo, with optional ?corskey= parameter for index.html.
* Default location is above London; use https://bboxfinder.com to find your own box.
* Format for finding location is Lat/Long; bbox will give coordinates in south-west-north-east format.
* Example: 35.317366,-81.035156,42.423457,-65.039063
* Use index.html?bounds=<location> with location above.
* Deploy index.html to favorite static HTML hosting (e.g. Github Pages or Cloudflare Pages).
* Request URL like https://...URL.../index.html?bounds=<bbox bounds>&corskey=<apikey>

https://github.com/video-db/Director

* # Director Framework for Video Agents
* Built on top of VideoDB's 'video-as-data' infrastructure, Director enables users to:
  - Summarize videos in seconds.
  - Search for specific moments.
  - Create clips instantly.
  - Integrate top GenAI projects and APIs and create and edit content instantly.
  - Add overlays, generate thumbnails, and much more.
* Built with flexibility in mind, Director is perfect for developers, creators, and teams looking to harness AI to simplify media workflows and unlock new possibilities.
* Experience a sleek, chat-based interface with built-in video playback and intuitive controls.
* Connect seamlessly with powerful AI tools like LLMs, databases, and GenAI APIs.
* Easily add new agents and tools to your workflow.
* Director's architecture brings together:
  - Backend Reasoning Engine: Handles workflows and decision-making.
  - Chat-Based UI: Engage with your media library conversationally.
  - Video Player: Advanced playback and interaction tools.
  - Collection View: Organize and browse your media effortlessly.
* At the heart of The Director is its Reasoning Engine, a powerful core that drives intelligent decision-making and dynamic workflows.
* Contextual Understanding: The engine analyzes user inputs and maintains context, ensuring smooth and coherent interactions with agents.
* Dynamic Agent Orchestration: Based on the user's needs, it identifies and activates the right agents to complete tasks efficiently.
* Modular Processing: Tasks are broken into smaller steps, allowing agents to collaborate and deliver accurate results in real time.
* Multi-Agent Coordination: Seamlessly integrates multiple agents to handle complex workflows, such as summarizing, editing, and searching videos.
* Real-Time Updates: Provides live progress and feedback as tasks are being completed.
* Extensible Design: Easily adaptable to include custom logic or connect to external APIs for more advanced capabilities.

https://github.com/virattt/ai-hedge-fund

- This is a proof of concept for an AI-powered hedge fund.
  The goal of this project is to explore the use of AI to make trading decisions.
  This project is for educational purposes only and is not intended for real trading or investment.

- The system employs several agents working together:
  - Valuation Agent - Calculates the intrinsic value of a stock and generates trading signals
  - Sentiment Agent - Analyzes market sentiment and generates trading signals
  - Fundamentals Agent - Analyzes fundamental data and generates trading signals
  - Technical Analyst - Analyzes technical indicators and generates trading signals
  - Risk Manager - Calculates risk metrics and sets position limits
  - Portfolio Manager - Makes final trading decisions and generates orders

- This project is for educational and research purposes only.
- Not intended for real trading or investment
- No warranties or guarantees provided
- Past performance does not indicate future results
- Creator assumes no liability for financial losses
- Consult a financial advisor for investment decisions

https://github.com/AlexShakaev/backtesting_and_algotrading_options_with_Interactive_Brokers_API

* this is an example of backtesting and automating options trading strategy with native Interactive Brokers python API (ibapi).
* Bot buys call spread on SPY when close price > sma, exits after 5 days or when abrupt downtrend is detected with bayesian change point detection algorithm (BOCD).
* Requirements:
  * Interactive Brokers account with market data subscriptions

https://github.com/Shubhamsaboo/awesome-llm-apps

* 💡 Discover practical and creative ways LLMs can be applied across different domains, from code repositories to email inboxes and more.

https://blog.moontower.ai/a-winner-thats-really-a-loser/

This is an in-depth analysis of a failed options trading strategy by Kris, a seasoned trader. Here’s a summary of the key points:

https://github.com/BrainBlend-AI/atomic-agents

Atomic Agents is an open-source Python library for building AI applications using various tools and services. Here’s a summary of the documentation:

https://github.com/jchanvfx/NodeGraphQt

* NodeGraphQt is a node graph UI framework written in PySide2 that can be re-implemented.

https://github.com/intellectronica/building-effective-agents-with-pydantic-ai

* Code examples for agentic AI patterns inspired by Building Effective Agents by Erik Schluntz and Barry Zhang
* Examples rely on Pydantic AI, an agentic AI orchestration library
* Complement original code accompanying the article
* Demonstrate foundational agentic AI patterns and use of Pydantic AI
* Provide API key placeholders for LLM providers (e.g. OpenAI, Gemini, Anthropic)
* Allow customization with specific AI model selection (e.g. GPT-4o, gemini-1.5-pro, claude-3-5-sonnet-latest)
* Optional: instrument Pydantic AI with Logfire for agent call tracking

https://github.com/iceener/ai

- Available tools:
  - Memory
  - Web (Firecrawl)
  - Email (Resend)
  - Linear (Linear)
  - Calendar (Google Calendar)
  - Map (Google Maps)
  - Spotify (Spotify)
  - File
  - Speech (ElevenLabs)
  - Search (Algolia and Qdrant)
  - Crypto
- Main logic has two modes: fast-track and thinking

https://github.com/browser-use/browser-use

* Enable AI to control your browser with Browser Use
* Install via pip: `pip install browser-use` (optional: `playwright install`)

https://github.com/ArturSepp/QuantInvestStrats

- qis package implements analytics for financial data visualization, performance reporting, and analysis of quantitative strategies.
- The package is split into 5 main modules with increasing dependency paths:
  - qis.utils
  - qis.perfstats
  - qis.plots
  - qis.models
  - qis.portfolio
- High-level module for analysis, simulation, backtesting, and reporting of performance and risk metrics.
- The package includes various examples for generating reports on:
    - Multi-asset performance (qis.examples.factsheets.multi_assets.py)
    - Strategy performance and risk (qis.examples.factsheets.strategy.py)
    - Strategy vs benchmark performance (qis.examples.factsheets.strategy_benchmark.py)
    - Multi-strategy sensitivity analysis (qis.examples.factsheets.multi_strategy.py)
- Examples for using the package in Jupyter notebooks are located here: qis/examples/notebooks

https://github.com/Zackriya-Solutions/meeting-minutes

* An AI-powered meeting assistant that captures live meeting audio, transcribes it in real-time, and generates summaries while ensuring user privacy.
* Offers:
	+ Privacy First: All processing happens locally on your device
	+ Cost Effective: Uses open-source AI models instead of expensive APIs
	+ Flexible: Works offline, supports multiple meeting platforms
	+ Customizable: Self-host and modify for your specific needs
	+ Intelligent: Built-in knowledge graph for semantic search across meetings
* Features:
	+ Modern, responsive UI with real-time updates
	+ Export to Markdown/PDF
	+ Real-time audio capture using SoundDevice
	+ Real-time audio visualization
	+ Automatic meeting detection (Zoom, Google Meet, Teams)
	+ Live audio transcription using OpenAI's Whisper
	+ Real-time display of transcription
	+ Post-meeting summarization
	+ Local processing for privacy
* Built with a modern stack focusing on performance and user privacy.
* Key Components:
	+ Frontend (Electron JS + Next JS): User interface and real-time updates, cross-platform desktop application, WebSocket communication
	+ Backend (FastAPI): Audio processing pipeline, AI integration and coordination, database operations
	+ AI Engine (Whisper + Qwen/Llama 3.2): Real-time transcription, meeting summarization, natural language processing

https://simonwillison.net/2024/Dec/27/open-webui/

* Opened the Open WebUI and tried it out for the first time, using uvx to run it with Python 3.11
* Installed dependencies and downloaded a large model (903MB) to ~/.cache/huggingface/hub/models--sentence-transformers--all-MiniLM-L6-v2
* Found a working Llama 3.2:3b chat interface that automatically detected Ollama on the laptop
* Added Datasette documentation to the "knowledge" section and could search for files with #
* Used spatialite.rst.txt and got a solid answer from the Llama 3.2 model
* Open WebUI has various features, including API model integration, web search, custom tools, and SQLite logging

https://github.com/DrewThomasson/ebook2audiobook

This is a detailed guide on how to use the ebook2audiobook project, which converts EPUB books into audiobooks. Here’s a concise summary:

https://github.com/marinabox/marinabox

* MarinaBox is a toolkit for creating and managing secure, isolated environments for AI agents
* Provides Secure Sandboxed Environments:
    - Run isolated browser and desktop sessions locally or cloud
    - Perfect for AI agent tasks and browser automation
* Comprehensive SDK & CLI:
    - Python SDK for programmatic control
    - Command-line interface for session management
    - Real-time monitoring and control capabilities
    - Integration with popular automation tools (Playwright, Selenium)
* Interactive UI Dashboard:
    - Live session viewing and control
    - Session recording and playback
    - Session management interface
    - Cloud Integration: Deploy sandboxes to major cloud providers (coming soon)
    - Multi-session Management: Run multiple isolated environments simultaneously
    - Session Tagging: Organize and track sessions with custom tags
* Requires:
    - Docker installed on the system
    - Python 3.12 or higher
    - pip (Python package installer)
* Installation instructions:
    - Pull required Docker images
    - Install the Marinabox package
    - Clone sandbox repository for other architectures (optional)
* Example usage of the Marinabox SDK:
    - Initialize and set up the SDK
    - Create a new session
    - List active sessions
    - Execute a computer use command

https://github.com/tabularis-ai/augini

* Demo: https://huggingface.co/spaces/tabularisai/augini
* augini is an AI-powered data assistant that brings RAG capabilities to tabular data (CSV, Excel, XLSX)
* Built with state-of-the-art language models, provides intuitive chat interface for data analysis and powerful data manipulation capabilities
* Works with any tabular format (CSV, Excel, Pandas DataFrames)
* Initialize Augini with API key and model
* Load data from CSV, Excel, or Pandas-supported format
* Start chatting with data using augini's chat interface
* Ask follow-up questions with context awareness
* Enhance datasets with AI-generated features (add synthetic features, generate custom features)
* Generate privacy-safe synthetic data while preserving statistical properties (anonymize data)
* Install using pip: pip install augini
* Get API key from OpenAI or OpenRouter
* Initialize Augini for OpenAI or OpenRouter
* Contact info@tabularis.ai for enterprise deployments, local installations, or custom solutions

https://github.com/g1ibby/auto-vpn

* Deploy your personal WireGuard VPN server with just a few clicks. No subscriptions, no complexity, full control.
* This project provides an effortless way to spin up your own temporary, cost-effective WireGuard VPN servers on-demand—no long-term subscriptions or complex manual setups required.
* By leveraging popular VPS providers like Vultr or Linode, it automatically:
    - On-Demand Deployment: Launch VPN servers instantly on Vultr or Linode
    - Cost-Effective: Pay only for actual usage with automatic server cleanup
    - User-Friendly Interface: Simple GUI for server and profile management
    - Enhanced Privacy: Full control over your VPN infrastructure
    - Automated Setup: Pre-configured WireGuard installation
    - Multi-Provider Support: Works with major VPS providers (Vultr, Linode)
* To deploy, create a data directory and run the container:
    - `mkdir data_layer`
    - `docker run --rm -d --pull always --name auto-vpn \
    -e USERNAME=admin \
    -e PASSWORD=qwerty \
    -e VULTR_API_KEY=<your-vultr-api-key> \
    -v $(pwd)/data_layer:/app/data_layer \
    -p 8501:8501 \
    ghcr.io/g1ibby/auto-vpn`
* Access the interface at `http://localhost:8501`
* To create a new web service, sign in to Render Dashboard and follow these steps:
    - Choose "New Web Service"
    - Select Docker runtime
    - Use image: `ghcr.io/g1ibby/auto-vpn`
* Configure environment variables for the service:
    - `USERNAME`: Admin login username
    - `PASSWORD`: Admin login password
    - `VULTR_API_KEY` or `LINODE_API_KEY`: VPS provider API key
    - `SELF_URL`: Your Render service URL (e.g., https://your-service.onrender.com)
        - `DATABASE_URL`: PostgreSQL connection string (recommended for persistence)
* The project leverages several powerful technologies:
    - Pulumi: Infrastructure as Code for VPS management
    - WireGuard: Secure VPN protocol
    - Streamlit: Modern web interface
    - Docker: Containerization and easy deployment
* The project provides the following features:
    - All VPN traffic is encrypted using WireGuard
    - No logs are kept on VPN servers
    - Servers are automatically destroyed after inactivity
    - Full control over infrastructure eliminates third-party trust
* Contributions are welcome!
    - DigitalOcean
    - Hetzner
    - AWS
    - QR code generation for WireGuard peers
    - Easy mobile device configuration
    - One-click peer sharing

https://github.com/ahmedkhaleel2004/gitdiagram

- Turn any GitHub repository into an interactive diagram for visualization in seconds.
- Instant Visualization: Convert any GitHub repository structure into a system design / architecture diagram
- Interactivity: Click on components to navigate directly to source files and relevant directories
- Fast Generation: Powered by Claude 3.5 Sonnet for quick and accurate diagrams
- Customization: Modify and regenerate diagrams with custom instructions
- API Access: Public API available for integration (WIP)
- Frontend: Next.js, TypeScript, Tailwind CSS, ShadCN
- Backend: FastAPI, Python, Server Actions
- Database: PostgreSQL (with Drizzle ORM)
- AI: Claude 3.5 Sonnet
- Deployment: Vercel (Frontend), EC2 (Backend)
- CI/CD: GitHub Actions
- Analytics: PostHog, Api-Analytics

https://github.com/ThReinecke/dutch_vocabulary

* This project automates daily delivery of an email containing words, translations, and example sentences for chosen language and difficulty level.
* It leverages ChatGPT as vocabulary source, affecting quality of provided content.
* The creator developed this to improve Dutch C1-level vocabulary with no suitable app available, leveraging consistency in checking emails over apps.
*
* Project components:
    * CloudWatch Event Rule triggers daily Lambda function.
    * Lambda retrieves new words from ChatGPT, stores them in DynamoDB, and sends via SES.
* Deployment requirements:
    + Tools installed: Python, pip, Terraform, AWS CLI.
    + Permissions required for AWS CLI user to deploy resources.
    + Verified Amazon SES email address matching project's email.
    + Optional: rezip Lambda deployment package after code changes using setup.sh script.
*
    + Prepare configuration:
        - Copy terraform.tfvars.example and variables.py, fill in values.
    * Run Terraform workflow commands: terraform init, plan, apply.
*
    + This project doesn't replace language learning with courses or apps but is a tool for engagement.
    + Industry-standard services like AWS and Terraform are preferred for their known support.

https://github.com/wtbates99/posture-pinger

* A real-time posture monitoring application that helps prevent poor posture while working at your computer
* Runs in system tray and uses computer vision to analyze posture through webcam
* System tray icon indicating posture status
* Available options in toolbar menu, including:
  * Poor posture alert notification
  * Configurable tracking intervals (continuous to 4-hour intervals)
  * Optional video window showing posture analysis
  * Automatic notifications when poor posture is detected
  * Cross-platform support (Windows, macOS, Linux)
  * Privacy-focused: All processing happens locally on your machine
* Leverages:
  * MediaPipe - Pose detection and landmark tracking
  * OpenCV - Video processing and visualization
  * PyQt6 - System tray interface
  * Platform-specific notification systems
* Requires Python 3.10
* Install dependencies with pip install -r requirements.txt
* Required packages for apt installation:
  * sudo apt install -y libxcb1 libxcb-xinerama0 libxcb-cursor0 libxkbcommon-x11-0 libxcb-render0 libxcb-render-util0
* Optional packages for additional features:
  * sudo apt install -y qt6-base-dev qt6-wayland libqt5x11extras5
* Install dependencies with pip install -r requirements.txt
* Launch application with python src/main.py
* Basic Usage:
  * Click tray icon to access menu
  * Select "Start Tracking" to begin monitoring
  * Enable video window (optional) to view pose detection
  * Select preferred tracking interval
  * Monitor posture score (0-100) via tray icon
* Note: Optional database logging is available for posture data tracking, which will support future features including posture history and modeling

https://github.com/bluxmit/alnoda-workspaces

* Open-source portable containerized workspaces for isolating work, making backups, copying, and moving between computers and cloud seamlessly.

https://github.com/thiswillbeyourgithub/AnkiAIUtils

Here is a high-level overview of the project and its requirements:

Project Overview

The project appears to be an Anki plugin that provides various features for managing and generating content, including:

Mnemonic generation
Image support
Tag management
Query filtering using LLM (Large Language Model)
Note editing and formatting

https://github.com/guoriyue/AutoMouser

* AutoMouser is a Chrome extension that tracks user interactions and generates Selenium test code using OpenAI's GPT model
* Supports real-time interaction tracking (clicks, inputs, scrolls)
* Generates automatic Selenium Python code
* Consolidates smart input data
* Detects window resize events
* Exports JSON action logs
* Offers multiple XPath generation strategies
* Produces clean, well-structured code output
* Clone or download the source code
* Create a .env file with your OpenAI API key
* Replace or edit the SELENIUM_PROMPT template if needed
* Enable Developer mode and load the extension in Chrome
* Start recording actions and generate code by clicking the icon
* Download two files: tracking_log.json and selenium_test.py
* Check and run the generated Selenium code in your Python environment
* Contributions are welcome, please submit pull requests or create issues