diff --git a/packages/app/app/components/RepoSearch.vue b/packages/app/app/components/RepoSearch.vue
index 6b5a971d..02f9c97d 100644
--- a/packages/app/app/components/RepoSearch.vue
+++ b/packages/app/app/components/RepoSearch.vue
@@ -1,44 +1,62 @@
 <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 eventSource: EventSource | null = null;
 const throttledSearch = useThrottle(search, 500, true, false);
 
+function closeEventSource(source: EventSource) {
+  source.close();
+  if (eventSource === source) {
+    eventSource = null;
+    isLoading.value = false;
+  }
+}
+
 watch(
   throttledSearch,
-  async (newValue) => {
-    activeController?.abort();
+  async (query) => {
+    if (eventSource) {
+      closeEventSource(eventSource);
+    }
     searchResults.value = [];
-    if (!newValue) {
+
+    if (!query) {
       isLoading.value = false;
       return;
     }
 
-    const controller = new AbortController();
-    activeController = controller;
-
     isLoading.value = true;
-    try {
-      const response = await fetch(
-        `/api/repo/search?text=${encodeURIComponent(newValue)}`,
-        { signal: activeController.signal },
-      );
-      const data = (await response.json()) as { nodes: RepoNode[] };
-      if (activeController === controller) {
-        searchResults.value = data.nodes ?? [];
-      }
-    } catch (err: any) {
-      if (err.name !== "AbortError") {
-        console.error(err);
+    const source = new EventSource(
+      `/api/repo/search?text=${encodeURIComponent(query)}`,
+    );
+    eventSource = source;
+
+    source.onmessage = (event) => {
+      if (event.data === "[DONE]") {
+        closeEventSource(source);
+        return;
       }
-    } finally {
-      if (activeController === controller) {
-        isLoading.value = false;
+
+      try {
+        const repo = JSON.parse(event.data) as RepoNode & { error?: string };
+        if (repo.error) {
+          return;
+        }
+
+        searchResults.value.push(repo);
+      } catch {
+        // Skip malformed JSON
       }
-    }
+    };
+
+    source.onerror = (err) => {
+      console.error(err);
+      closeEventSource(source);
+    };
   },
   { immediate: false },
 );
diff --git a/packages/app/server/api/repo/search.get.ts b/packages/app/server/api/repo/search.get.ts
index eb8764dc..5592eb30 100644
--- a/packages/app/server/api/repo/search.get.ts
+++ b/packages/app/server/api/repo/search.get.ts
@@ -1,267 +1,137 @@
+import stringSimilarity from "string-similarity";
 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;
+const INSTALLATION_CACHE_TTL_MS = 5 * 60 * 1000;
+
+interface CachedRepos {
+  fetchedAt: number;
+  repos: Array<{
+    id: number;
+    name: string;
+    private: boolean;
+    owner: { login: string; avatar_url: string };
+    stargazers_count?: number;
   }>;
 }
 
+const installationRepoCache = new Map<number, CachedRepos>();
+
 export default defineEventHandler(async (event) => {
-  const request = toWebRequest(event);
-  const signal = request.signal;
+  const query = await getValidatedQuery(event, (data) =>
+    querySchema.parse(data),
+  );
 
-  const flowErrors: SearchDebugInfo["flowErrors"] = [];
-  const flowStages: SearchDebugInfo["flowStages"] = [];
+  if (!query.text) {
+    return { nodes: [] };
+  }
 
-  const addFlowStage = (stage: string, details?: string) => {
-    flowStages.push({
-      stage,
-      timestamp: new Date().toISOString(),
-      details,
-    });
-  };
+  const { signal } = toWebRequest(event);
 
-  const addFlowError = (
-    stage: string,
-    error: string,
-    repositoryContext?: string,
-  ) => {
-    flowErrors.push({
-      stage,
-      error,
-      timestamp: new Date().toISOString(),
-      repositoryContext,
-    });
-  };
+  setResponseHeaders(event, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  });
 
-  try {
-    addFlowStage("query_validation", "Starting query validation");
+  const app = useOctokitApp(event);
+  const searchText = query.text.toLowerCase();
 
-    const query = await getValidatedQuery(event, (data) =>
-      querySchema.parse(data),
-    );
+  async function getInstallationRepos(installationId: number) {
+    const cached = installationRepoCache.get(installationId);
+    const now = Date.now();
 
-    if (!query.text) {
-      addFlowStage("early_return", "Empty query text");
-      return { nodes: [], debug: null };
+    if (cached && now - cached.fetchedAt < INSTALLATION_CACHE_TTL_MS) {
+      return cached.repos;
     }
 
-    addFlowStage("query_validated", `Query: "${query.text}"`);
-
-    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}`);
+      const octokit = await app.getInstallationOctokit(installationId);
+      const { data } = await octokit.request("GET /installation/repositories", {
+        per_page: 100,
+      });
+      installationRepoCache.set(installationId, {
+        fetchedAt: now,
+        repos: data.repositories,
+      });
+      return data.repositories;
+    } catch {
+      if (cached) {
+        return cached.repos;
+      }
+      throw new Error("Unable to load repositories");
     }
+  }
 
-    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;
-
-    addFlowStage(
-      "repository_iteration_start",
-      `Starting to iterate repositories for search: "${searchText}"`,
-    );
-
-    try {
-      await app.eachRepository(async ({ repository }) => {
-        try {
-          if (signal.aborted) {
-            addFlowStage(
-              "search_aborted",
-              `Aborted at repository: ${repository.full_name}`,
-            );
-            status = "aborted";
-            return;
-          }
+  async function* iterateMatches() {
+    const seen = new Set<number>();
 
-          if (repository.private) {
-            skippedRepositories++;
-            return;
-          }
+    for await (const { installation } of app.eachInstallation.iterator()) {
+      if (signal.aborted) {
+        return;
+      }
 
-          processedRepositories++;
+      try {
+        const repos = await getInstallationRepos(installation.id);
 
-          // Add periodic progress tracking
-          if (processedRepositories % 100 === 0) {
-            const elapsed = Date.now() - startTime;
-            addFlowStage(
-              "progress_checkpoint",
-              `Processed ${processedRepositories} repositories in ${elapsed}ms`,
-            );
+        for (const repo of repos) {
+          if (repo.private || seen.has(repo.id)) {
+            continue;
           }
 
-          const repoName = repository.name.toLowerCase();
-          const ownerLogin = repository.owner.login.toLowerCase();
-
-          let nameScore, ownerScore;
-          try {
-            nameScore = stringSimilarity.compareTwoStrings(
-              repoName,
-              searchText,
-            );
-            ownerScore = stringSimilarity.compareTwoStrings(
-              ownerLogin,
-              searchText,
-            );
-          } 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;
-          }
+          const name = repo.name.toLowerCase();
+          const owner = repo.owner.login.toLowerCase();
+          const score = Math.max(
+            stringSimilarity.compareTwoStrings(name, searchText),
+            stringSimilarity.compareTwoStrings(owner, searchText),
+          );
 
-          try {
-            matches.push({
-              id: repository.id,
-              name: repository.name,
+          if (
+            score > 0.3 ||
+            name.includes(searchText) ||
+            owner.includes(searchText)
+          ) {
+            seen.add(repo.id);
+            yield JSON.stringify({
+              id: repo.id,
+              name: repo.name,
               owner: {
-                login: repository.owner.login,
-                avatarUrl: repository.owner.avatar_url,
+                login: repo.owner.login,
+                avatarUrl: repo.owner.avatar_url,
               },
-              stars: repository.stargazers_count || 0,
-              score: Math.max(nameScore, ownerScore),
+              stars: repo.stargazers_count || 0,
             });
-          } 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;
           }
-          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;
+      } catch {
+        // Skip suspended installations
       }
     }
 
-    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`);
+    yield "[DONE]";
+  }
 
-    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,
-    };
+  const stream = new ReadableStream<string>({
+    async start(controller) {
+      const send = (data: string) => {
+        controller.enqueue(`data: ${data}\n\n`);
+      };
 
-    return { nodes: top, debug: debugInfo };
-  } catch (error) {
-    addFlowError("global_error", (error as Error).message);
+      try {
+        for await (const match of iterateMatches()) {
+          send(match);
+        }
+      } catch (err) {
+        send(JSON.stringify({ error: (err as Error).message }));
+      } finally {
+        controller.close();
+      }
+    },
+  });
 
-    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.pipeThrough(new TextEncoderStream());
 });