Category: Daily Report

Cursor can now do automations.

Target:

Custom platform -> web hooks … users will provide feature requests and bugs found … agents will attempt to implement … humans will QA and merge PRs.

Introduction

If you’re building AI-powered features like semantic search or working with Large Language Models (LLMs), you’ve probably encountered terms like “vectors,” “embeddings,” “token embeddings,” and “neural network weights.” These concepts are often confusing because they’re related but serve very different purposes.

This guide will clarify:

• What embedding vectors are and how they’re used for search
• The difference between embedding vectors and token embeddings
• How LLMs actually generate text (spoiler: they don’t “reverse” vectors)
• What neural network weights are
• Why you can’t convert a vector back to original text

Part 1: Embedding Vectors (For Semantic Search)

What Is a Vector? (The General Term)

A vector is simply a list of numbers. In mathematics, it’s an array of numerical values.

Common Misconception: “Vectors are always 3D (three numbers) representing points in 3D space”

Reality: Vectors can have any number of dimensions (any number of values), not just 3!

Examples:

• `[5]` – a 1-dimensional vector (just one number)
• [1, 2]` – a 2-dimensional vector (two numbers, like x, y coordinates)
• [1, 2, 3]` – a 3-dimensional vector (three numbers, like x, y, z in 3D space)
• `[0.5, -0.2, 0.8, 0.1]` – a 4-dimensional vector (four numbers)
• [0.123, -0.456, 0.789, …, 0.234]` – a 768-dimensional vector (768 numbers!)

Why the Confusion?

3D graphics (video games, 3D modeling) popularized the concept of vectors as `[x, y, z]` coordinates, but that’s just **one use case** of vectors.

Vectors are used everywhere in computing:

• Graphics: `[x, y, z]` represents a 3D position (3 dimensions)
• 2D Graphics: `[x, y]` represents a 2D position (2 dimensions)
• Data science: `[age, height, weight, income]` represents a person’s attributes (4 dimensions)
• Machine learning: `[feature1, feature2, …, feature100]` represents data features (100 dimensions)
• Embeddings: `[0.123, -0.456, …, 0.789]` represents text meaning (768 dimensions)

The “Space” Concept

While 3D vectors represent points in 3D space, higher-dimensional vectors represent points in higher-dimensional spaces:

• 2D vector = point in 2D space (a flat plane)
• 3D vector = point in 3D space (our physical world)
• 768D vector = point in 768-dimensional space (abstract mathematical space)

You can’t visualize 768-dimensional space, but mathematically it works the same way – it’s just more dimensions!

What Is an Embedding Vector? (The Specific Term)

An embedding vector is a specific type of vector that represents text (or other data) in a way that captures its semantic meaning.

Key Point: An embedding vector IS a vector, but it’s a vector with a specific purpose – to encode meaning.

The Relationship:

– ✅ An embedding vector **is** a vector (it’s a list of numbers)

– ❌ Not all vectors are embedding vectors (vectors can represent many things)

Think of it like this:

Vector = A container (like a box)

Embedding vector = A specific type of box (one that contains meaning-encoded numbers)

What Are Embedding Vectors?

An embedding vector is a numerical representation of text that captures its semantic meaning. Think of it as converting words into a list of numbers that represent what the text “means” rather than what it “says.”

How They Work

When you vectorize text like “Government announces new climate policy,” the embedding model converts it into a list of numbers:

Original: “Government announces new climate policy”

Vector: [0.123, -0.456, 0.789, 0.234, -0.567, …] (768 numbers for nomic-embed-text)

Key Characteristics

• It’s a Vector: A list of numbers (e.g., 768 numbers for nomic-embed-text)
• One-Way Transformation: Text → Vector (lossy compression)
• Semantic Meaning: Similar meanings produce similar vectors
• Fixed Dimensions: Each model produces vectors of a fixed size (e.g., 768 numbers)
• Cannot Be Reversed: You cannot convert the vector back to the original text

Terminology Note

In practice, people often say:

– “Vector” when they mean “embedding vector” (in AI/ML context)

– “Embedding” when they mean “embedding vector”

These are usually interchangeable in conversation, but technically:

– Vector = General term (any list of numbers)

– Embedding = The process of converting data to vectors

– Embedding vector = The resulting vector from embedding

Why Can’t You Reverse a Vector?

Think of it like a fingerprint:

– A fingerprint uniquely identifies a person

– But you can’t reconstruct the entire person from just their fingerprint

– Similarly, a vector captures the “essence” of text meaning, but not the exact words

Mathematical Reason: The transformation is lossy – information is compressed and discarded. Multiple different texts could theoretically produce similar (or even identical) vectors, so reversing would be ambiguous.

Use Case: Semantic Search

Embedding vectors excel at finding semantically similar content:

Example:

– You search for: “climate policy changes”

– The system finds:

– “Government announces new carbon tax legislation” (high similarity)

– “Parliament debates environmental protection bill” (high similarity)

– “Manchester United wins match” (low similarity – correctly excluded)

Even though these articles don’t contain the exact words “climate policy changes,” they’re semantically related.

How Similarity Works in High Dimensions:

Just like you can measure distance between two points in 3D space:

– 3D: Distance = √[(x₁-x₂)² + (y₁-y₂)² + (z₁-z₂)²]

You can measure “distance” (similarity) between two points in 768D space:

– 768D: Similarity = cosine of angle between vectors

The math works the same way, just with more dimensions!

Embedded Models Are Already Trained

The models have already been trained on billions of words and their ‘closeness’ to each other, which is why when you vectorise an article (or something else) using vector searches will find semantically similar content.

Whilst exact keyword search is slightly faster, vector search enables search through meaning, which means it’s a lot more flexible.

For companies to win during this major transformation, the key principle is having someone at C level who is responsible for integrating AI. This person must understand the business workflows and combine that with AI knowledge. The creation of a Head of AI role is the first step to take in your AI transformation.

Initially the AI role is focused on becoming more effective at what the company does currently i.e. making X widgets faster, better, or looking after more customers for less money in customer service. But in reality, the real winners will be the ones who innovate with AI.

Finally got to a decent point this week on the software side. The prototype I built a while back needed to be reworked into something with proper architecture. I’ve been experimenting with different “vibe coding” apps—mainly Cursor lately—but that’s been getting worse. The prototype was interesting, but I knew I had to put it into a solid framework. That meant spending some time learning, then implementing.

Now that’s done, and I’ve got a platform where you can manage your data, apply AI workflows to it, and get useful output. There are still a few things to iron out, but overall I’m happy with the progress. Such are the wonders (and headaches) of programming.

Why thinking through pitch decks and financial projections matters

Over the last 24 hours I’ve started working on the pitch deck and financial projections for this AI platform. We needed to define a clear initial niche, and this exercise forced that thinking.

The brain—mind, subconscious, whatever you want to call it—feeds on the information we give it. Your future reality is largely shaped by how you use your mind. When you actually spend time thinking things through (not just asking ChatGPT to spit something out), your brain begins mapping the future. It starts planning at a subconscious level.

(As an aside: Psycho-Cybernetics is worth a read on this topic—there’s evidence the conscious/subconscious dynamic doesn’t work quite the way we’ve been taught.)

So when you see a spreadsheet forecasting customer numbers on specific dates, your brain takes it as truth and begins working toward it. Of course, it all depends on your mindset at the time, but clarity + projection = momentum.

Progress this week

I finally integrated AI workflows into the platform. It took time because I wanted the right architecture around it, but it’s now functional.

I’m fairly certain the software of the future will be heavily abstracted away from us.

The future of software = Speech recognition + LLM + MCP + Generative UI

Here’s my best guess: most of the software we use today will eventually be abstracted away. Speech recognition + LLMs is already good enough that you can just talk to your software, which is sufficient for many use cases.

A simple example: forms. Instead of filling out endless fields, you’ll just say what you want. The system will validate your input, confirm it, and submit. In fact, an AI “agent” that already knows your preferences will fill it out for you automatically—eventually you won’t even need to speak.

For now, point-and-click interfaces will still exist, because they’re efficient for certain tasks. But speech → LLM → MCP → Generative UI is where things are heading. LLMs understand intent, query services, get the data, and then spin up a UI on the fly if needed.

— note … super tired so this is half tidied up by AI … may rewrite it tomorrow with fresh eyes

The client will send this

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "elicitation": {}
    },
    "clientInfo": {
      "name": "example-client",
      "version": "1.0.0"
    }
  }
}

The server will respond like this

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "tools": {
        "listChanged": true
      },
      "resources": {}
    },
    "serverInfo": {
      "name": "example-server",
      "version": "1.0.0"
    }
  }
}

Notes

• If protocol versions are different, advised to terminate the connection to avoid any incompatible requests being made.
• The capabilities object lists the primitives support, although I need to get more definitive on the full array of potential options
• The server, in this example, has a tools object within capabilities, and rather than at first glance being limited to just the listChanged notification… it means the entire tool primitive methods are available AS WELL AS the listChanged.
• The resources object means the entire primitive is available for resources, so /list /read

Once the client checks the response from the server, it sends out a one way notification, expecting no immediate response:

{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}

Google completely wiped the floor with independent content publishers a few years ago; instead promoting websites that venture capitalists had (potentially) shared interests in.

I wrote about that here in my post ‘Google’s Move Kills Small Independents & Keeping Going…‘

This week Google have effectively won an important ruling in court where they won’t have to take the harmful action of breaking up its company. I’m not always a fan of forcing large companies to break up because after all, free market American capitalism is about competition and winning (at all costs) … but as I’ve grown older I’ve also realised that corporations are essential dead psychopaths with no real reason to do anything good for humanity … so there do need to be checks in place, and the anti-monopoly laws are a good start.

The legal case focused on the dominance in search of which, since we now know that Google are inherently biased and throttle any information which might give you a different perspective on things, is a major problem in trying to at least maintain a free and open society.

Google has done a great deal of good but seems to have got worse as a product over the years. It’s not just the preferential treatment to some topics, but it’s also how internet marketers have used it to try and sell you something at every corner. It’s difficult to find good well loved websites on Google that aren’t backed by highly profitable entities.

Anyway, because of the case, they don’t need to sell their Chrome Browser or break anything else up.

The main problem now though is the new Google AI summaries and the complete overhaul of the Google results service currently only available in the USA.

DMG Media, owner of MailOnline, Metro and other outlets, said AIO resulted in a fall in click-through-rates by as much as 89%, in a statement to the Competition and Markets Authority made in July.

This is an astounding drop, but not unexpected. The future for getting traffic through search for the average joe is going to be increasingly difficult. Of course, we may well see new attempts at search engines filling this gap as more people start realising Google isn’t helping the little guy anymore.

Social networks and communities will continue to be a good source of traffic for the independent publishers.

That’s all for now.

MCP Clients have their own set of primitives:

• Sampling
• Elicitation
• Logging

MCP Client Primitive Sampling

I need to test this out but it seems there is a sampling/complete method that a server can send to a client, which essentially asks the client to complete a LLM request. The reason for this is seemingly when the MCP server itself doesn’t want to handle a LLM itself … so it passes it off to the client.

MCP Client Primitive Elicitation

There’s also a straightforward elicitation/request method where the server will ask the client for further information from the user.

MCP Client Primitive Logging

Involving debugging and monitoring, servers can send logs to the clients.

Notifications

The protocol also has facility for real-time updates from server to client, in the form of JSON-RPC 2.0 notifications. Nothing super new there.