diff --git a/packages/app/app/components/RepoSearch.vue b/packages/app/app/components/RepoSearch.vue
index 6b5a971d..2f53f83a 100644
--- a/packages/app/app/components/RepoSearch.vue
+++ b/packages/app/app/components/RepoSearch.vue
@@ -1,43 +1,76 @@
 <script lang="ts" setup>
 import type { RepoNode } from "../../server/utils/types";
+
 const search = useSessionStorage("search", "");
 const searchResults = ref<RepoNode[]>([]);
 const isLoading = ref(false);
 
-let activeController: AbortController | null = null;
+let abortController: AbortController | null = null;
 const throttledSearch = useThrottle(search, 500, true, false);
 
 watch(
   throttledSearch,
-  async (newValue) => {
-    activeController?.abort();
+  async (query) => {
+    abortController?.abort();
     searchResults.value = [];
-    if (!newValue) {
+
+    if (!query) {
       isLoading.value = false;
       return;
     }
 
     const controller = new AbortController();
-    activeController = controller;
-
+    abortController = controller;
     isLoading.value = true;
+
     try {
       const response = await fetch(
-        `/api/repo/search?text=${encodeURIComponent(newValue)}`,
-        { signal: activeController.signal },
+        `/api/repo/search?text=${encodeURIComponent(query)}`,
+        { signal: controller.signal },
       );
-      const data = (await response.json()) as { nodes: RepoNode[] };
-      if (activeController === controller) {
-        searchResults.value = data.nodes ?? [];
+
+      const reader = response.body?.getReader();
+      if (!reader) return;
+
+      const decoder = new TextDecoder();
+      let buffer = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6);
+          if (data === "[DONE]") return;
+
+          try {
+            const repo = JSON.parse(data) as RepoNode & { error?: string };
+            if (repo.error) continue;
+
+            // Insert sorted by stars, keep top 10
+            const idx = searchResults.value.findIndex(
+              (r) => r.stars < repo.stars,
+            );
+            searchResults.value.splice(
+              idx === -1 ? searchResults.value.length : idx,
+              0,
+              repo,
+            );
+            if (searchResults.value.length > 10) searchResults.value.pop();
+          } catch {
+            // Skip malformed JSON
+          }
+        }
       }
     } catch (err: any) {
-      if (err.name !== "AbortError") {
-        console.error(err);
-      }
+      if (err.name !== "AbortError") console.error(err);
     } finally {
-      if (activeController === controller) {
-        isLoading.value = false;
-      }
+      if (abortController === controller) isLoading.value = false;
     }
   },
   { immediate: false },
diff --git a/packages/app/server/api/repo/search.get.ts b/packages/app/server/api/repo/search.get.ts
index eb8764dc..c9bcc0b5 100644
--- a/packages/app/server/api/repo/search.get.ts
+++ b/packages/app/server/api/repo/search.get.ts
@@ -1,267 +1,91 @@
 import { z } from "zod";
 import { useOctokitApp } from "../../utils/octokit";
 import stringSimilarity from "string-similarity";
-import type { RepoNode } from "../../utils/types";
 
 const querySchema = z.object({
   text: z.string(),
 });
 
-interface SearchDebugInfo {
-  startTime: string;
-  endTime: string;
-  totalElapsedMs: number;
-  processedRepositories: number;
-  matchesFound: number;
-  averageProcessingTimePerRepo: number;
-  repositoriesPerSecond: number;
-  searchQuery: string;
-  status: "completed" | "aborted" | "error";
-  flowErrors: Array<{
-    stage: string;
-    error: string;
-    timestamp: string;
-    repositoryContext?: string;
-  }>;
-  flowStages: Array<{
-    stage: string;
-    timestamp: string;
-    details?: string;
-  }>;
-}
-
 export default defineEventHandler(async (event) => {
-  const request = toWebRequest(event);
-  const signal = request.signal;
-
-  const flowErrors: SearchDebugInfo["flowErrors"] = [];
-  const flowStages: SearchDebugInfo["flowStages"] = [];
-
-  const addFlowStage = (stage: string, details?: string) => {
-    flowStages.push({
-      stage,
-      timestamp: new Date().toISOString(),
-      details,
-    });
-  };
-
-  const addFlowError = (
-    stage: string,
-    error: string,
-    repositoryContext?: string,
-  ) => {
-    flowErrors.push({
-      stage,
-      error,
-      timestamp: new Date().toISOString(),
-      repositoryContext,
-    });
-  };
-
-  try {
-    addFlowStage("query_validation", "Starting query validation");
-
-    const query = await getValidatedQuery(event, (data) =>
-      querySchema.parse(data),
-    );
-
-    if (!query.text) {
-      addFlowStage("early_return", "Empty query text");
-      return { nodes: [], debug: null };
-    }
-
-    addFlowStage("query_validated", `Query: "${query.text}"`);
+  const query = await getValidatedQuery(event, (data) =>
+    querySchema.parse(data),
+  );
 
-    let app;
-    try {
-      addFlowStage("octokit_init", "Initializing Octokit app");
-      app = useOctokitApp(event);
-      addFlowStage("octokit_ready", "Octokit app initialized successfully");
-    } catch (err: any) {
-      addFlowError("octokit_init", err.message);
-      throw new Error(`Failed to initialize Octokit: ${err.message}`);
-    }
+  if (!query.text) {
+    return { nodes: [] };
+  }
 
-    const searchText = query.text.toLowerCase();
-    const matches: RepoNode[] = [];
-    const startTime = Date.now();
-    let processedRepositories = 0;
-    let status: SearchDebugInfo["status"] = "completed";
-    let skippedRepositories = 0;
-    let suspendedErrors = 0;
+  const { signal } = toWebRequest(event);
 
-    addFlowStage(
-      "repository_iteration_start",
-      `Starting to iterate repositories for search: "${searchText}"`,
-    );
+  setResponseHeaders(event, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  });
 
-    try {
-      await app.eachRepository(async ({ repository }) => {
-        try {
-          if (signal.aborted) {
-            addFlowStage(
-              "search_aborted",
-              `Aborted at repository: ${repository.full_name}`,
-            );
-            status = "aborted";
-            return;
-          }
+  const app = useOctokitApp(event);
+  const searchText = query.text.toLowerCase();
+  const seen = new Set<number>();
 
-          if (repository.private) {
-            skippedRepositories++;
-            return;
-          }
-
-          processedRepositories++;
-
-          // Add periodic progress tracking
-          if (processedRepositories % 100 === 0) {
-            const elapsed = Date.now() - startTime;
-            addFlowStage(
-              "progress_checkpoint",
-              `Processed ${processedRepositories} repositories in ${elapsed}ms`,
-            );
-          }
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      const send = (data: string) =>
+        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
 
-          const repoName = repository.name.toLowerCase();
-          const ownerLogin = repository.owner.login.toLowerCase();
+      try {
+        for await (const { installation } of app.eachInstallation.iterator()) {
+          if (signal.aborted) break;
 
-          let nameScore, ownerScore;
           try {
-            nameScore = stringSimilarity.compareTwoStrings(
-              repoName,
-              searchText,
-            );
-            ownerScore = stringSimilarity.compareTwoStrings(
-              ownerLogin,
-              searchText,
+            const octokit = await app.getInstallationOctokit(installation.id);
+            const { data } = await octokit.request(
+              "GET /installation/repositories",
+              { per_page: 100 },
             );
-          } catch (err: any) {
-            addFlowError(
-              "string_similarity",
-              err.message,
-              repository.full_name,
-            );
-            // Use fallback scoring
-            nameScore = repoName.includes(searchText) ? 0.5 : 0;
-            ownerScore = ownerLogin.includes(searchText) ? 0.5 : 0;
-          }
 
-          try {
-            matches.push({
-              id: repository.id,
-              name: repository.name,
-              owner: {
-                login: repository.owner.login,
-                avatarUrl: repository.owner.avatar_url,
-              },
-              stars: repository.stargazers_count || 0,
-              score: Math.max(nameScore, ownerScore),
-            });
-          } catch (err: any) {
-            addFlowError("match_creation", err.message, repository.full_name);
-          }
-        } catch (err: any) {
-          if (
-            err.message?.includes("suspended") ||
-            err.message?.includes("Installation")
-          ) {
-            suspendedErrors++;
-            addFlowError(
-              "repository_suspended",
-              err.message,
-              repository.full_name,
-            );
-            return;
+            for (const repo of data.repositories) {
+              if (repo.private || seen.has(repo.id)) continue;
+
+              const name = repo.name.toLowerCase();
+              const owner = repo.owner.login.toLowerCase();
+              const score = Math.max(
+                stringSimilarity.compareTwoStrings(name, searchText),
+                stringSimilarity.compareTwoStrings(owner, searchText),
+              );
+
+              if (
+                score > 0.3 ||
+                name.includes(searchText) ||
+                owner.includes(searchText)
+              ) {
+                seen.add(repo.id);
+                send(
+                  JSON.stringify({
+                    id: repo.id,
+                    name: repo.name,
+                    owner: {
+                      login: repo.owner.login,
+                      avatarUrl: repo.owner.avatar_url,
+                    },
+                    stars: repo.stargazers_count || 0,
+                  }),
+                );
+              }
+            }
+          } catch {
+            // Skip suspended installations
           }
-          addFlowError(
-            "repository_processing",
-            err.message,
-            repository.full_name,
-          );
-          throw err;
         }
-      });
 
-      addFlowStage(
-        "repository_iteration_complete",
-        `Completed repository iteration`,
-      );
-    } catch (err: any) {
-      if (
-        err.message?.includes("suspended") ||
-        err.message?.includes("Installation")
-      ) {
-        addFlowError(
-          "iteration_suspended",
-          `Installation suspended after processing ${processedRepositories} repositories: ${err.message}`,
-        );
-        status = "completed";
-      } else {
-        addFlowError("iteration_failed", err.message);
-        status = "error";
-        throw err;
+        send("[DONE]");
+      } catch (err) {
+        send(JSON.stringify({ error: (err as Error).message }));
+      } finally {
+        controller.close();
       }
-    }
-
-    const totalElapsed = Date.now() - startTime;
+    },
+  });
 
-    addFlowStage("sorting_matches", `Sorting ${matches.length} matches`);
-
-    try {
-      matches.sort((a, b) =>
-        b.score !== a.score ? b.score - a.score : b.stars - a.stars,
-      );
-      addFlowStage("sorting_complete", "Matches sorted successfully");
-    } catch (err: any) {
-      addFlowError("sorting", err.message);
-    }
-
-    const top = matches.slice(0, 10).map((node) => ({
-      id: node.id,
-      name: node.name,
-      owner: node.owner,
-      stars: node.stars,
-    }));
-
-    addFlowStage("response_preparation", `Prepared ${top.length} top results`);
-
-    const debugInfo: SearchDebugInfo = {
-      startTime: new Date(startTime).toISOString(),
-      endTime: new Date().toISOString(),
-      totalElapsedMs: totalElapsed,
-      processedRepositories,
-      matchesFound: matches.length,
-      averageProcessingTimePerRepo:
-        processedRepositories > 0 ? totalElapsed / processedRepositories : 0,
-      repositoriesPerSecond: processedRepositories / (totalElapsed / 1000),
-      searchQuery: query.text,
-      status,
-      flowErrors,
-      flowStages,
-    };
-
-    return { nodes: top, debug: debugInfo };
-  } catch (error) {
-    addFlowError("global_error", (error as Error).message);
-
-    return {
-      nodes: [],
-      error: true,
-      message: (error as Error).message,
-      debug: {
-        startTime: new Date().toISOString(),
-        endTime: new Date().toISOString(),
-        totalElapsedMs: 0,
-        processedRepositories: 0,
-        matchesFound: 0,
-        averageProcessingTimePerRepo: 0,
-        repositoriesPerSecond: 0,
-        searchQuery: "",
-        status: "error" as const,
-        flowErrors,
-        flowStages,
-      },
-    };
-  }
+  return stream;
 });