Forem: Julian

Why I Love These Kinds of Challenges 🔥

Julian — Sat, 28 Feb 2026 03:24:13 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

First of all, I absolutely love events like this! More than the economic rewards, they push you to explore new platforms and tools. Once you grasp what each one can really do, the potential you unlock is simply incredible! Huge thanks to DevTo for creating this space. 🙌

What I Learned

This particular challenge felt super interesting because it encouraged building your portfolio in a more intuitive way. In my opinion, classic portfolios are becoming less common when job hunting these days — but they remain an amazing tool for self-reflection: realizing everything you’ve learned, achieved, and how far you’ve come.
That’s why I decided to theme mine around trading 📈. I’ve been trading for several years now, and lately I’ve had much more consistent success. We traders spend countless hours in terminals watching charts, analyzing news, tracking prices… So why not turn the place where we live every day into a showcase of my professional experience?

With the support of Gemini, solid documentation, and several reference examples, I was finally able to bring my project to life. Here are the key sections I created:

A live ticker that runs constantly, displaying year-over-year improvement percentages for each technology I use.
A line/pie chart combo showing my professional growth from the very beginning, the industries I’ve worked in, and the experience I’ve accumulated.
A trade history section designed like a real position log — you can see how long I held each trade, the role I played, and the simulated successful impact of every operation.
Technologies classified by years of experience, visualized as volume bars for quick understanding.
My favorite part: a gallery powered by Power BI Embedded — visitors can explore real public reports I’ve built without ever leaving the page, giving a clear idea of the visual storytelling I can deliver.
Finally, a studies/highlights section styled like quick news cards to review my education and key milestones.

Demo

LINK:Interactive Trading CV

Google Gemini Feedback 🌐

One thing I didn’t know before was how straightforward it is to use Google for free/static hosting of your site — it was awesome! At first, I struggled to understand the instructions and exactly what was required. But after reading the docs and leaning on Gemini again, everything became surprisingly simple. You connect it directly to your repo and it just works.
Honestly, this hosting part was the most challenging for me. I was also worried about potential future charges, but setting up Google billing alerts for when costs exceed a certain threshold, plus sticking to the simplest hosting tier, kept everything under control and protected me from surprise bills — something many people don’t consider when jumping into these challenges.

Next Step: Your Feedback on My CV! 📄

I’d love to give my CV a second pass and hear your thoughts. Do you find it easy to read and understand? Any tips or suggestions would be super valuable!
Thanks for continuing to create spaces where we learn and grow every single day! Big hug to everyone — let’s keep building this amazing community together. 🤗
What do you think of the trading-themed portfolio approach? Would love to read your comments or experiences below! 🚀

Why I Love These Kinds of Challenges 🔥

Julian — Sat, 28 Feb 2026 03:24:13 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Learned

With the support of Gemini, solid documentation, and several reference examples, I was finally able to bring my project to life. Here are the key sections I created:

A live ticker that runs constantly, displaying year-over-year improvement percentages for each technology I use.
A line/pie chart combo showing my professional growth from the very beginning, the industries I’ve worked in, and the experience I’ve accumulated.
A trade history section designed like a real position log — you can see how long I held each trade, the role I played, and the simulated successful impact of every operation.
Technologies classified by years of experience, visualized as volume bars for quick understanding.
My favorite part: a gallery powered by Power BI Embedded — visitors can explore real public reports I’ve built without ever leaving the page, giving a clear idea of the visual storytelling I can deliver.
Finally, a studies/highlights section styled like quick news cards to review my education and key milestones.

Demo

LINK:Interactive Trading CV

Google Gemini Feedback 🌐

Next Step: Your Feedback on My CV! 📄

CLI Tool that analyzes git repos and generates beautiful documentation!

Julian — Mon, 16 Feb 2026 02:57:16 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

💡 Project Background

We can't deny that using "vibe coding" and AI tools makes our process of creating new programs and software much more efficient. However, one major issue I've encountered is that we can sometimes lose visibility into what's actually being built—or even forget what we did in previous commits.
That's why I decided to build a CLI tool powered by GitHub Copilot to solve this problem!

DocWeave is a command-line tool that analyzes your git repository and generates organized documentation using GitHub Copilot CLI. It transforms your commit history into markdown docs, Mermaid diagrams, and AI-powered insights.
DocWeave extends AI to post-coding tasks. It turns rapid development into professional, well-documented outputs, making developers and teams more efficient.

Problem Solved

Developers often face "documentation debt" where code evolves faster than docs, leading to:

Onboarding delays for new team members
Bugs from misunderstandings
Reduced productivity (20-50% of dev hours on docs per Gartner reports)

DocWeave automates documentation creation, saving time and improving project maintainability.

✨ Features

🤖 AI-Powered Analysis: Uses GitHub Copilot CLI to understand code changes and provide context
📊 Visual Diagrams: Generates Mermaid diagrams (timelines, file relationships, importance charts)
📝 Auto-Documentation: Creates organized markdown files in DocweaveDocs/ folder
🎯 Next Steps: Suggests actionable next steps based on code analysis
⚡ Simple CLI: Just run docweave analyze in any git repository
🔄 Graceful Fallback: Works even without Copilot CLI using intelligent heuristics

📝 Example Use Cases

Solo Developer: After a coding session, analyze commits and generate documentation
Team Collaboration: Generate changelogs and architecture diagrams for team reviews
Code Review: Auto-document PR changes with AI-powered context
Onboarding: Create up-to-date documentation for new team members
Project Handoff: Generate comprehensive documentation before transferring a project

Demo

Repo:https://github.com/Juls95/DocWeave/tree/main

📖 Usage

Basic Usage

# Navigate to any git repository
cd /path/to/your/repo

# Analyze last 5 commits (default)
docweave analyze

# Analyze only the last commit (quick)
docweave analyze --last

Options

# Analyze last commit only (quick analysis)
docweave analyze --last

# Analyze last 5 commits (default)
docweave analyze

# Analyze specific number of commits
docweave analyze --limit 20

# Analyze specific repository
docweave analyze --path /path/to/repo
# or short: docweave analyze -p /path/to/repo

# Analyze commits from last 7 days only
docweave analyze --days 7
# or short: docweave analyze -d 7

# Combine options
docweave analyze --path ./my-repo --limit 15 --days 30

📁 Generated Documentation

DocWeave creates a DocweaveDocs/ folder in your repository with:

🏗️ Architecture

src/docweave/
├── cli.py              # CLI entrypoint and command handling
├── components/         # Reusable components
│   ├── copilot_integration.py  # GitHub Copilot CLI integration
│   └── doc_generator.py        # Documentation generation
├── features/           # Business logic
│   └── commit_analysis.py      # Git commit analysis
├── lib/                # Utilities
│   ├── copilot_check.py        # Copilot CLI availability check
│   ├── repo_utils.py           # Repository path utilities
│   └── utils.py               # General utilities
└── types/              # Type definitions
    └── models.py               # Data models

My Experience with GitHub Copilot CLI

Before Copilot CLI, I had to constantly ask LLMs or IDEs to explain what they understood, request a specific format, provide templates for generating documentation, and ensure everything was correct. Now, with GitHub Copilot, I can be confident that—as a n*ative GitHub development* tool—it fully analyzes all the information available in the repo and generates content strictly following the specified templates.

GitHub Copilot CLI provides AI-powered analysis that:

Understands code context and intent
Provides deeper insights into why changes were made
Suggests more relevant next steps
Generates better summaries

Trading CV- A different and interactive way to share your skills.

Julian — Fri, 30 Jan 2026 17:04:19 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hi DEVelopers!
I'm Julian, a Data Analyst and Software Engineer with 9 years of experience. Lately, I've been learning a lot about how to apply my knowledge of gaining insights from data to create models and be more accurate when trading! So, I did my best to create my CV as a trading system, where you can explore and view all charts, embedded Power BI reports, and my experience in one single trading console. Enjoy!

Portfolio

LINK:Interactive Trading CV

How I Built It

🚀 Project Overview

This portfolio leverages the visual language of stock market dashboards (Bloomberg Terminal, TradingView) to present professional experience. Instead of a static PDF, users interact with "assets" (skills), view "market performance" (career growth), and read "analyst reports" (case studies).

Key Design Principles:

Google Stack: Antigravity and AI Studio
Theme: Dark Mode, Cyberpunk/Financial aesthetics.
Interaction: Real-time feedback, pulsing indicators, and glassmorphism.
Data-Driven: Every UI element represents a datapoint from over 9 years of experience.

🛠️ Technology Stack

This application is built with a modern, high-performance stack:

Core Framework: React with TypeScript (Vite)
Styling: Tailwind CSS for utility-first styling.
Animations: Framer Motion for fluid transitions and modal effects.
Data Visualization: Recharts for the main career performance chart.
Icons: Lucide React for consistent, lightweight iconography.

📦 Features & Component Architecture

The application is structured into a single-page dashboard containing several specialized modules:

1. Market Performance (Main Chart)

Visuals: Switchable Area Chart and Candlestick Chart.
Data: Visualizes career timeline vs. "Market Value" (Role seniority/Impact).
Interactive: Hover tooltips showing stack usage per role and company logos (Clearbit API).
Markers: "Dividend" markers representing major industries entered.

2. Skills Market Depth

Visuals: Order book style list.
Logic: Skills are ranked by "Volume" (Years of Experience) and "Depth" (Competency Level).
Assets: SQL, Python, PowerBI, RPA, etc.

3. Experience Feed

Visuals: Scrolling news ticker / social feed.
Content: Chronological history of roles, companies, and high-impact bullets (e.g., "+20% Efficiency").

4. Analyst Reports (Gallery)

Visuals: Card grid with hover effects.
Function: Opens "Reports" (Deep dives/Case studies) in an embedded modal view. Links to external PowerBI/Fabric dashboards.

5. Fundamentals (Bio & Stats)

Content: Education, Certifications, Contact Links.
Footer: Quick access to GitHub, LinkedIn, and Email.

What I'm Most Proud Of

Trading features: You can feel like you're inside a trading interface, with my experience translated into trading info.
Embedded reports from Power BI: Just click on the gallery images, and you can interact with the reports right there!
Animations: Subtle and beautiful animations to catch your attention!

SleepSync - FullStack App made with Xano and Bubble

Julian — Sun, 14 Dec 2025 20:43:46 +0000

This is a submission for the Xano AI-Powered Backend Challenge: Full-Stack, AI-First Application

What I Built

My app unifies sleep and health data from Oura and Whoop wearables into a "Truth Score™" (a unified metric, e.g., 0-100, calculated by averaging or weighting key metrics like sleep duration, readiness/recovery scores, HRV, resting heart rate, etc.). For this initial version, we'll simulate API integrations by allowing users to upload CSV files.

Demo

Bubble Full Stack App

The AI Prompt I Used

Generate a complete Xano backend in XanoScript for a sleep data unification app called SleepSync. Include: Authentication (email/password signup/login endpoints returning JWT). Database tables: users (id, email, password_hash, created_at), oura_data (user_id, date, total_sleep_seconds, readiness_score, resting_heart_rate, hrv, etc. – base on Oura CSV fields like deep_sleep_duration, respiratory_rate), whoop_sleeps (user_id, cycle_start_time, asleep_duration_min, recovery_score, resting_heart_rate_bpm, hrv_ms, etc.), unified_data (user_id, date, unified_sleep_hours, unified_rhr, unified_hrv, truth_score). API Endpoints: POST /auth/signup (create user, hash password, generate user_id), POST /auth/login (validate, return JWT), POST /upload/csv (authenticated, accept file/type 'oura' or 'whoop', parse CSV, insert with user_id from JWT, normalize timestamps to UTC), GET /data/unified (authenticated, query by user_id/date range, compute unified metrics like unified_sleep_hours = avg(Oura total_sleep/3600, Whoop asleep_min/60); truth_score = avg(Oura readiness, Whoop recovery); store in unified_data). Use XanoScript syntax ($db, $auth). Handle errors, nulls (default 0). Assume CSVs have headers. Make scalable for multiple uploads.

How I Refined the AI-Generated Code

I found samples of the scripts on the documentation. These samples allowed me to use them in Cursor to be more specific and aligned to the information required by Xano.

I opened the XanoScript in my configuration settings on my workspace. Should I copy paste actual code there? Also, I found below code in the initial script

workspace SleepSyncBackend {
  acceptance = {ai_terms: false}
  preferences = {
    internal_docs    : false
    track_performance: true
    sql_names        : false
    sql_columns      : true
  }
}

Let's do this only for OURA data. How should I create each one of the steps you mentioned? Should I configure something in Bubble or Xano? Consider this official guide:
https://www.xano.com/learn/connect-xano-bubble/

My Experience with Xano

Xano is really good to make a Backend usable and safe. The problems that I found is that I didn't find any Discord or social chat to interact with the community and nowadays that's frustrating due all the help shouldn't be left to documentation or an AI bot.

🌟 My Experience at ETH New York 2025

Julian — Mon, 25 Aug 2025 23:19:09 +0000

10 days ago, I had the opportunity to attend ETH New York, an event hosted by the ETH Global foundation where hackers from around the globe gather to test their technical skills and compete for sponsor prizes. Over an intense 36 hours, I developed an MVP (Minimum Viable Product) for my project, Founil, which implements innovative features to tackle real-world blockchain challenges. 🚀

💡 The Project: Founil and Uniswap v4 Hooks

My project, hosted at GitHub, leverages Uniswap, one of the most prominent decentralized exchange (DEX) protocols built on Ethereum. The goal is to address the growing issue of scam tokens and fraudulent schemes in the blockchain space, affecting both lesser-known and socially prominent projects. 💻

Founil introduces a groundbreaking funding platform that combines NFTs (Non-Fungible Tokens) and Liquidity Pools to create a donation and reward mechanism. NFTs serve as a record of contributions from donors, while Uniswap liquidity pools provide market liquidity, generate transaction revenue, and enable project creators to withdraw funds in a controlled manner, preventing potential scams. 🪙

🛠️ How It Works: Liquidity Bootstrapped Pool

Using Uniswap v4 hooks, I implemented a Liquidity Bootstrapped Pool. Users swap a token, such as ETH, for a collateral token defined by the project creator. This collateral funds the liquidity pool, which is released gradually to prevent bots from buying low and selling high—a common issue in today’s blockchain ecosystem.

Once the liquidity pool is funded, the hooks capture transaction fees, initially distributed to the project creator. A portion of these fees is reinvested into the pool via Auto Compound, growing the pool over time. Additionally, the afterSwap hook automatically mints NFTs, recording who donated, when, and how much. These NFTs allow for donor verification and can be traded or held for future project benefits. 🎮

🔒 Transparency and Security

A core feature of Founil is transparency. Project creators must provide evidence of how and where funds are used and define a clear mechanism for gradual fund withdrawals. This ensures donors are not defrauded and that projects deliver on their promises, fostering trust within the community. ✅

What do you think of Founil? Any advice to win a Hackathon prize next time? Share your thoughts or suggestions in the comments to help improve this project! 🚀

Thanks for reading!

Submission deadline

Julian — Sun, 24 Aug 2025 19:12:41 +0000

Hello!

I've looked into the official challenge post (https://dev.to/challenges/brightdata-n8n-2025-08-13) and the submission date is August 31

But in this post https://dev.to/devteam/new-demo-videos-from-the-n8n-and-bright-data-teams-for-the-real-time-ai-agents-challenge-3of3 says it's on 07 September. Could anyone confirm the exact dates for the submission deadline, please?

Your personal Blockchain tutor powered by AssemblyAI

Julian — Sun, 27 Jul 2025 02:58:53 +0000

This is a submission for the AssemblyAI Voice Agents Challenge

What I Built

1. Overview of the Voice Agent and Prompt Categories Addressed

The voice-based Crypto Education Agent is designed to provide interactive, personalized learning experiences in cryptocurrency topics through natural voice interactions. It uses AssemblyAI for real-time speech-to-text (STT) transcription, handling domain-specific jargon like "BTC," "DeFi," and "zero-knowledge proofs" with high accuracy. The transcribed queries are processed via a Retrieval-Augmented Generation (RAG) pipeline built with LlamaIndex, which retrieves factual information from a curated knowledge base stored in Pinecone vector database. Responses are generated using Anthropic's Claude LLM, ensuring detailed, hallucination-free explanations. The agent also learns from conversations by indexing dialogue history, enabling personalized follow-ups, such as building on prior queries about staking to explain related DeFi concepts.

Key features include:

Low-latency interactions: Achieving ~300ms transcription via AssemblyAI's Universal-Streaming, making it feel like a real-time conversation.
Domain-specific enhancements: Word boosts in AssemblyAI improve transcription accuracy for crypto terms to 95%+.
Educational tools: Supports use cases like concept explanations, quizzes, market insights, and interactive quizzes.
Testing and scalability: Validated through 5 structured use cases with metrics for accuracy, relevance, and personalization; built for future extensions like live market APIs.

This agent primarily addresses the following prompt categories:

Domain Expert: It acts as a specialized tutor in cryptocurrency education, drawing from a tailored knowledge base to explain complex topics (e.g., blockchain fundamentals or NFT terms) accurately and contextually, reducing hallucinations through RAG.
Real-Time Performance: Leveraging AssemblyAI's streaming STT for low-latency voice input, it enables seamless, interactive sessions where users can speak queries and receive immediate responses, with conversation learning for dynamic personalization.

While it could indirectly support Business Automation (e.g., automating educational workflows in trading advisory), the core focus is on expert knowledge delivery and performant real-time interactions.

Demo

GitHub Repository

Juls95 / assembly_ai

AssemblyAI RAG with Learning System

A comprehensive system that combines AssemblyAI's Universal-Streaming technology with Retrieval-Augmented Generation (RAG) using LlamaIndex, Anthropic, and Pinecone. This project enables real-time speech-to-text transcription, semantic search, and conversational AI with long-term learning capabilities.

🏗️ Project Structure

assembly_ai/
├── assembly.py                 # Main AssemblyAI streaming implementation
├── build_rag_index.py         # Pinecone index construction
├── rag_with_learning.py       # RAG chat engine with learning
├── transcribe_test_audio.py   # Batch audio transcription
├── crypto_kb/                 # Knowledge base documents
├── test_audio/                # Audio test samples
├── test_cases.json           # Test case definitions
└── .env                      # Environment variables (create this)

🚀 Features

Real-time Speech-to-Text: Using AssemblyAI's Universal-Streaming API
Domain-Specific Word Boost: Enhanced recognition for crypto/finance terminology
RAG Pipeline: Semantic search with Pinecone and LlamaIndex
Long-term Learning: Conversation history integration
Batch Testing: Audio transcription accuracy evaluation
Multi-Modal Input: Support for both live audio and pre-recorded files

📺 Demo Video

Watch a demonstration…

View on GitHub

Technical Implementation & AssemblyAI Integration

Using AssemblyAI's capabilities

def run_batch_tests():
    # Use the API key from Assembly
    aai.settings.api_key = api_key
    # Use the word_boost list
    config = aai.TranscriptionConfig(word_boost=word_boost)
    # Defines config fot the Assembly usage.
    transcriber = aai.Transcriber(config=config)

    with open("test_audio/test_cases.json", "r") as f:
        test_cases = json.load(f)

    for case in test_cases:
        transcript = transcriber.transcribe(case["filename"]).text
        print(f"Expected: {case['expected_transcript']}")
        print(f"Got: {transcript}")
        print()

Explanation:

Iterates through a set of test cases, each with an audio file (.wav) and an expected transcript simulating a real time conversation.
Transcribes each file and prints both the expected and actual results for comparison.

Importance:

Provides a simple but effective way to evaluate transcription accuracy and system performance.
Supports regression testing and quality assurance for the speech-to-text pipeline.

Testing AssemblyAI's real time processing

microphone_stream = aai.extras.MicrophoneStream(sample_rate=8000)
for chunk in microphone_stream:
    print("Audio chunk read:", len(chunk))
    break  # Remove break to keep reading, this is just to test
client.stream(microphone_stream)

Explanation:

This snippet tests live microphone audio capture by reading a chunk and printing its size.
The break is used to only read one chunk for debugging.
After confirming audio capture, the stream is passed to AssemblyAI for real-time transcription.
Not a priority for MVP but implementing in future versions.

Importance:

Ensures that the microphone is correctly configured and audio is being captured before starting a full streaming session.
Helps debug device index and sample rate issues, which are common in cross-platform audio applications.

Testing AssemblyAI's accuracy and storing date for future process

transcripts = []
for case in test_cases:
    audio_path = case["filename"]
    transcript = transcriber.transcribe(audio_path)
    transcripts.append(transcript.text)
    print(f"Transcript for {audio_path}: {transcript.text}")

# Save transcripts for RAG queries
with open("transcripts.json", "w") as f:
    json.dump(transcripts, f)

Explanation:

This code batch-transcribes a set of audio files, storing the resulting transcripts.
Each transcript is printed and then saved to a JSON file for later use.
Imagine each transcript is the result of the real-time conversation with a normal user.

Importance:

Enables the integration of audio data into the RAG pipeline, allowing spoken content to be indexed and retrieved semantically.
Supports workflows where knowledge is captured from meetings, podcasts, or other audio sources.

Creating core vector index for RAG system

vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context, embed_model=embed_model)

Explanation:

This code builds the core vector index for the RAG system.
PineconeVectorStore connects LlamaIndex to a managed Pinecone vector database.
StorageContext manages how data is stored and retrieved.
VectorStoreIndex.from_documents ingests all documents using the specified embedding model (here, HuggingFace's all-MiniLM-L6-v2), ensuring all vectors are compatible with the Pinecone index dimension.

Importance:

This is the foundation for semantic search and retrieval in your RAG pipeline.
Using HuggingFace embeddings ensures local, API-free operation and avoids OpenAI dependencies.
Ensures that all downstream retrieval and chat operations are based on a robust, scalable vector store.

Simulating human conversation with the agent (AssemblyAI, LlamaIndex, Anthropic)

# Simulate conversation loop
for query in queries:
    response = chat_engine.chat(query)  # Uses history
    print(f"Query: {query}\nResponse: {response}\n")

    # Update index with convo for long-term learning
    from llama_index.core import Document
    convo_doc = Document(text=f"User: {query} | Agent: {response}")
    index.insert(convo_doc)

Explanation:

This loop simulates a user-agent conversation.
Each query is sent to the chat engine, which uses the RAG index and LLM (Anthropic) to generate a response.
After each exchange, the conversation is wrapped as a Document and inserted into the index, enabling the system to "learn" from new interactions.

Importance:

Demonstrates how the system can perform continual learning, updating its knowledge base with new conversational data.
This enables adaptive, context-aware responses and supports use cases like personalized assistants or evolving knowledge bases.

Algolia MCP enriches your Data through Claude Natural Language!🚀🍀🥇

Julian — Thu, 24 Jul 2025 13:29:41 +0000

This is a submission for the Algolia MCP Server Challenge

What I Built

The primary use case revolves around automating the enrichment of Inc5000 company data stored in an Algolia index. Inc5000 refers to the annual list of the fastest-growing private companies in the United States, published by Inc. Magazine. The data includes attributes like company name, industry, growth rate, and years on the list (yrs_on_list). The goal is to enhance this dataset with AI-generated insights to make it more valuable for search, analysis, or business intelligence purposes.This enrichment is powered by Anthropic's Claude AI model, integrated via API calls within an n8n workflow

Demo

Repo

Juls95 / algoliaMCP

Algolia Node.js MCP – n8n Integration Guide

Watch the video above for a walkthrough of the n8n workflow integration process.

🚀 Quick Start: n8n Workflow Integration

This guide explains how to connect Algolia Node.js MCP to your custom n8n workflows, enabling you to trigger automations from Claude Desktop or any MCP-compatible client.

1. Clone and Install MCP

git clone https://github.com/Juls95/algoliaMCP.git
cd algoliaMCP
npm install

2. Configure and Start MCP

Authenticate with Algolia:
```
node src/app.ts authenticate
```
Start the MCP server:
```
node src/app.ts start-server
```

3. Configure Claude Desktop (or MCP Client)

Add this to your Claude Desktop configuration:

{
  "mcpServers": {
    "algolia-mcp": {
      "command": "<PATH_TO_BIN>/node",
      "args": [
        "--experimental-strip-types",
        "--no-warnings=ExperimentalWarning",
        "<PATH_TO_PROJECT>/src/app.ts"
      ]
    }
  }
}

Restart Claude Desktop after saving changes.

🆕 How the n8n Workflow Tool Works

The tool triggerN8nWorkflow is included by default and registered automatically.
…

View on GitHub

How I Utilized the Algolia MCP Server

Algolia MCP Server: A local server that exposes Algolia's APIs (search, update, analysis) as tools accessible via natural language.
- Claude Desktop: Anthropic's app that integrates MCP as a custom tool, allowing users to converse with Claude and invoke Algolia actions dynamically.

Launch MCP Server: Run the Algolia MCP locally, configured with Algolia API keys. It listens for prompts and translates them into API calls.
Integrate with Claude Desktop: Add MCP as a tool in Claude Desktop's settings, enabling Claude to use it for tasks involving Algolia.
Issue Natural Language Commands: In Claude Desktop, prompt something like: "Search Algolia for companies with yrs_on_list:17, enrich with research on trends and categories, then update the index."
Claude Processes the Prompt:
- Claude interprets the intent.
- Invokes MCP tools: First, a search tool to fetch data, parses the data and iterates over each item
- Uses its own reasoning or API calls for enrichment (e.g., generating summaries/trends).
- Calls MCP's update tool to push changes back to Algolia.

Key Takeaways

How It Worked Step by Step

The system operates in two main phases: the core n8n workflow to fetch and update data form Algolia and the integration with Claude Desktop + Algolia MCP for agentic enhancements. Below is a detailed, sequential breakdown based on the provided details.

Setup Overview:
1. Wait for the message from Claude with the commands from the user.
2. Link to n8n: The agentic flow can trigger or extend the n8n workflow. For example, Claude sends information to n8n using the MCP for further agentic processing.
Fetching Data from Algolia:
- An HTTP Request node sends a POST request to Algolia's search endpoint: /1/indexes/inc5000/query.
- The request body includes filters like "yrs_on_list:17" to target companies with exactly 17 years on the list.
- Additional parameters:
  - distinct=1: Ensures only one record per company (deduplication).
  - Custom ranking: desc(year) to prioritize the most recent entries.
  - hitsPerPage:5: Limits results per page for manageable batches.
  - attributesToRetrieve: ["objectID", "company_name", "industry", "growth_rate", "yrs_on_list"]: Retrieves only essential fields to optimize performance.
- Pagination is handled by starting with page=0. After processing a page, an IF condition checks if nbHits > (page+1)*hitsPerPage; if true, the page increments, and the workflow loops back to fetch the next page.

Iterating Over Fetched Records:
- The fetched data (an array of "hits") is split using an Item Lists node to break it into individual items.
- A Loop Over Items node (using splitInBatches v3) processes each item one by one with batchSize=1. This ensures sequential, reliable handling, avoiding parallel API overloads.
Enriching Each Company with Claude API:
- For each company record, an HTTP Request node calls Anthropic's Claude API: POST /v1/messages.
- Model used: claude-3-5-sonnet-20240620.
- The prompt instructs Claude to generate:
  - A 100-word summary based on the company's details (e.g., name, industry, growth rate).
  - Predicted trends (e.g., market expansions or challenges).
  - Categories (e.g., sector classifications).
  - Tags and scores (e.g., 'Fast-Growing' with a score of 8/10, 'Tech Innovator' with 7/10).
- The prompt specifies JSON output for easy parsing.
Parsing the Claude Response:
- A Set node extracts fields from Claude's JSON response: summary, trends, categories, objectID.
- This node merges the new enriched data with the original Algolia record.
Updating Algolia with Enriched Data:
- Another HTTP Request node uses Algolia's partialUpdateObject API (single-object endpoint) for reliability.
- It sends updates one by one using the Admin API Key.
- This avoids batch failures; if one update fails, others continue.
- Key fix: Ensured the JSON body is correctly formatted without unnecessary JSON.parse on arrays.
Aggregating Enriched Records Across Iterations and Pages:
- As the loop processes items and pages, a Merge node (in "All Item Data" mode) accumulates all enriched records into a global array.
- A Set node helps manage this aggregation, ensuring data from multiple pages and iterations is collected without loss.
Sending Completion Email:
- Once all processing is done, a Send Email node (v2.1) uses SMTP (e.g., Gmail with App Password) to notify the user.

Key Challenges Resolved During Implementation

Iteration Issues: Initial problems with looping over arrays were fixed by using Item Lists to split hits and setting batchSize=1 for per-item processing.
Aggregation: Switched to "All Item Data" mode in Merge nodes, with careful pagination accumulation to build a complete list.
Update Failures: Batch updates were unreliable, so switched to single-object endpoints; also corrected JSON body handling.
Email Formatting: Used array methods (.map/.join) to create readable lists in HTML.

Thanks for reading!

Data Culture in the Tech Era

Julian — Mon, 14 Jul 2025 19:57:14 +0000

Working in data and technology is highly sought after these days, especially with the massive implementation of tech tools and the vast amount of information generated. In this post, I'll share relevant aspects that I believe should be taken into account before starting deliverables and requesting projects with internal teams. 🚀📊

Data Culture

It is the foundation of all data implementation. Beyond releasing new features every day or implementing new technologies, we must be able to understand and assist the organization in a general way. Primarily, we need to foster a healthy data culture in which the entire team of a company is involved, not just executive levels, but also managerial and collaborative ones. This will make it clear who the users involved in the structure of data project definition will be, as well as the processes that will be improved and the technology that will be necessary, from which we can gradually dispense.

Business Alignment

Added to the executive sponsor, having business alignment is what will give us the opportunity to know how everything we do is solving real problems, contributing to a better work area, facilitating problem-solving, and optimizing time and resources. This business alignment should be focused on understanding from the business side what they are currently doing, using, what hurts them, what they lack, and why they use what they currently have. This last point must be primordial to improve current processes and not work redundantly in the future.

Content Management

Now, the relevance of understanding what strategy works for us in the business is where everything will take shape. Where do we start? What works for us? How do we divide and assign tasks and jobs? Right here, we analyze everything obtained from the three topics previously raised. According to Microsoft (https://learn.microsoft.com/en-us/power-bi/guidance/fabric-adoption-roadmap-content-ownership-and-management), we can have three ways to handle this content: Business-led self-service BI, managed self-service BI, and Enterprise BI. Depending on the strategy we choose, it will influence our operational model, our CoE, etc.

Delivery Scope

Now that we know how the team will be managed and what strategy benefits us, we'll review how we'll deliver the reports. For this, we have possible four levels of scope, starting from fewer to more users: (Personal, Team, Departmental, and Enterprise).

Conversely, for creating content at each stage, it is expected that the greater the number of consumers, the fewer creators per level. This is to have greater control and governance over the reports.

Center of Excellence

To clearly manage the delivery of reports, we must create a CoE that allows us to evangelize the company's people with our data-driven culture, train them, guide them, and educate them so that they have good practices when creating their reports and the risks of incorrect use of data or visualizations are minimized. 🔍💡

Governance

It is a very open topic; however, it can be summarized that its objective is to govern what users do with the data, ensuring that the company's data is well managed. For this, we must promote users to be able to work with certain internal measures that align with the organization, have consistency in documentation, deploying, and standardization of processes, and added to this, have a reduction in possible data leaks beyond the limits set by the organization and the BI team.

What do you think about these aspects? Share your thoughts in the comments and let's have a productive discussion!

Hackathon scanner to spark your next big idea!

Julian — Mon, 07 Jul 2025 00:39:37 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

A hackathon scanner for DoraHacks to gain insights into which projects are winning and their themes. No more headaches searching for what to build—just get inspired, imagine, and execute.

Demo

Full Video w/excel
Runner H Process

How I Used Runner H

To start, I explored the DoraHacks hackathon page to determine how to retrieve data from completed hackathons with announced winners. Then, I identified the relevant information on the page and configured Runner H to process it. Below is a detailed explanation of the process:

### Step 1: Get Ready
- Create a new Google Sheets file called "DoraHacks_Hackathon_Data".
- Make three sections (sheets) in the file:
  - Sheet 1: Hackathon Details
  - Sheet 2: Hackathon Winners
  - Sheet 3: Winner Projects

### Step 2: List the Hackathon Pages
- Use these five hackathon report pages:
  - https://dorahacks.io/hackathon/xion/report
  - https://dorahacks.io/hackathon/calimero-x-icp/report
  - https://dorahacks.io/hackathon/cambrian-hack/report
  - https://dorahacks.io/hackathon/aixfintech/report
  - https://dorahacks.io/hackathon/core-gaming-hackathon/report

### Step 3: Collect Information from Each Hackathon Page
For each hackathon page, do the following:

#### 3.1 Visit the Hackathon Page
- Go to the hackathon report page using the link.

#### 3.2 Get Hackathon Summary
- Find the "Hackathon Summary" section.
- Write down:
  - Hackathon name
  - Description
  - Prize amount
  - Start and end dates
  - Any other details (like number of participants or themes)
- Save this information with labels like:
  - Hackathon Name, Summary Description, Prize Amount, Dates, Other Details

#### 3.3 Get Hackathon Winners
- Find the "Hackathon Winners" section.
- For each winner, write down:
  - Winner or team name
  - Project name (if shown)
  - Prize or rank (like 1st or 2nd place)
  - Link to the winner’s project page on DoraHacks
- Save this information with labels like:
  - Hackathon Name, Winner Name, Project Name, Prize or Rank, Winner Link

#### 3.4 Get Organization Overview
- Find the "Organization Overview" section.
- Write down:
  - Organization name
  - Description
  - Any other details (like their goals or website)
- Save this information with labels like:
  - Hackathon Name, Organization Name, Organization Description, Other Details

### Step 4: Collect Information from Each Winner’s Project Page
For each winner’s project link found in Step 3.3:

#### 4.1 Visit the Winner’s Project Page
- Go to the winner’s project page using the link.

#### 4.2 Get Project Details
- Write down:
  - Project name (usually at the top)
  - Introduction (the text describing the project)
  - Tags (like DeFi or NFT, shown as labels or categories)
  - The project page link (the URL you’re on)
- Save this information with labels like:
  - Hackathon Name, Project Name, Introduction, Tags, Project Link

### Step 5: Put the Information into Google Sheets
Add the collected information to the Google Sheets file like this:

#### 5.1 Sheet 1: Hackathon Details
- Use these columns:
  - Hackathon Name
  - Summary Description
  - Prize Amount
  - Dates
  - Other Summary Details
  - Organization Name
  - Organization Description
  - Other Organization Details
  - Hackathon Link
- For each hackathon, add one row with the information from Steps 3.2 and 3.4, plus the hackathon page link.

#### 5.2 Sheet 2: Hackathon Winners
- Use these columns:
  - Hackathon Name
  - Winner Name
  - Project Name
  - Prize or Rank
  - Winner Link
- For each winner from Step 3.3, add one row.

#### 5.3 Sheet 3: Winner Projects
- Use these columns:
  - Hackathon Name
  - Project Name
  - Introduction
  - Tags
  - Project Link
- For each winner project from Step 4.2, add one row.

### Step 6: Handle Missing Information
- If a section (like Hackathon Summary) isn’t there, write "Not available" in that field.
- If a winner’s link doesn’t work, skip it and note the hackathon name and link as a problem.
- Make sure every field has something, even if it’s "N/A", to keep the sheets consistent.

### Step 7: Save and Share the Google Sheets File
- Save all the information in the Google Sheets file.
- Create a link to the file that others can view.
- Share the link with the user.

## Final Output
- The result is a Google Sheets file named "DoraHacks_Hackathon_Data" with three sheets filled with the collected information.
- The user gets a link to view the file.

Use Case & Impact

Developers: Easily discover which projects are winning in recent hackathons, enabling clearer decisions on what to build without spending excessive time starting from scratch. Identify winning projects and use them as inspiration for your own.
Investors: Find potential investment opportunities or talent in hackathons with significant prizes or specific themes.

Social Love

https://x.com/julsr_mx/status/1942020484779905467

Intelligent AI Data agent

Julian — Sat, 05 Jul 2025 22:18:58 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

Get the insights and data to invest in a smart way! Runner H is capable of simulating the action of going to CoinMarketCap, organizing the data in descending order and starting to explore the top 10. Likewise, it enters the X account of each project with the intention of obtaining their followers and following. All of this is summarized and added to an Excel file to view information quickly and consolidated.

Demo

Surfer 2: The Next Generation of Cross-Platform Computer-Use Agents - H Company

We are a frontier AI research company that designs, builds, and deploys cost-efficient agentic AI systems directly into enterprises’ core workflows and processes.

hcompany.ai

How I Used Runner H

Runner H is capable of simulating the action of going to CoinMarketCap, organizing the data in descending order and starting to explore the top 10. Likewise, it enters the X account of each project with the intention of obtaining their posts and interactions. All of this is summarized and added to an Excel file to view information quickly and consolidated.

Below is a step-by-step guide which explains how the agent works:

## Step 1: Access and Sort the DeFi Page
- Open your web browser and navigate to the following URL: https://coinmarketcap.com/view/defi/.
- Locate the sorting option on the page (typically found near the column headers).
- Sort the list by "Volume" in descending order (highest to lowest) to identify the top-performing DeFi assets based on trading volume.

## Step 2: Extract Data from the Top 10 Assets
- From the sorted list, identify the first 10 assets.
- For each of these assets, click on their respective links to visit their individual pages.
- On each asset's page, gather the following information:
  - **Market Cap**: The total market capitalization of the asset.
  - **Volume**: The 24-hour trading volume.
  - **Price**: The current price of the asset.
  - **Project Name**: The official name of the project.
  - **How It’s Used**: A brief description of the project’s purpose or utility (e.g., decentralized finance applications, staking, etc.).
- Calculate the **Percentage Change of Volume** for each asset over the last 24 hours (this data is often available on the page; note the change and determine if it’s positive or negative).
- Create a column labeled **Percentage Indicator** and mark it as "Positive" or "Negative" based on the volume change.

## Step 3: Gather Additional Information from the About Page
- For each of the 10 assets, modify the URL https://coinmarketcap.com/currencies/[symbol]/#About by replacing [symbol] with the asset’s unique symbol (e.g., https://coinmarketcap.com/currencies/uni/#About for Uniswap).
- Visit each modified URL and extract:
  - **About Title**: The title or headline of the "About" section.
  - **About Description**: A summary or detailed explanation of the project from the "About" section.

## Step 4: Create and Populate a Google Sheets Document
- Open Google Sheets and create a new spreadsheet.
- Name the first tab "DeFi_Analysis".
- Set up the following columns in the first row:
  - Symbol
  - Volume
  - Percentage Change
  - Percentage Indicator
  - Market Cap
  - Price
  - About Title
  - About Description
- Enter the collected data for each of the 10 assets into the corresponding rows under these columns.

## Step 5: Collect Twitter Information
- For each of the 10 assets, visit their official Twitter (X) profiles (links are often provided on their CoinMarketCap pages or through a quick search).
- Record the following details:
  - **Twitter Handle**: The asset’s official Twitter username (e.g., @Uniswap).
  - **Followers**: The number of followers the account has.
  - **Following**: The number of accounts the asset follows.
- Create a new tab in the same Google Sheets document and name it "Twitter_Data".
- Set up the following columns in the first row of the "Twitter_Data" tab:
  - Symbol
  - Twitter Handle
  - Followers
  - Following
- Enter the collected Twitter data for each of the 10 assets into the corresponding rows.

## Step 6: Review and Save
- Double-check all entered data for accuracy across both tabs.
- Save the Google Sheets document with a descriptive name (e.g., "DeFi_Analysis_2025-07-05") to ensure easy access for future reference.

Use Case & Impact

Both investors and developers benefit from this agent as it saves them a lot of time by not having to search and go page by page identifying what's new in trending. With the exploration, it obtains important information to identify the relevance of the project as well as the activity on X, knowing if they are projects that are working actively and avoiding making an incorrect decision based on price hype but taking into account price data and interactions.

Social Love

https://x.com/julsr_mx/status/1941622691389374647