Show HN: GPT-4-powered web searches for developers (phind.com)

thanks! 'Creative' mode puts less emphasis the web results we feed in and allows the model to say things that aren't explicitly fed in (and potentially hallucinate more).

Thanks! We're going to have a 'Pro' tier where users can ask much longer questions and paste in longer code snippets among other productivity-focused features.

Love to hear it! Expert mode is a new feature that has always been GPT-4 augmented with our custom web context.

It’s totally possible right now but at .002c for 750 words it could easily cost 10c for a single search.

I think that's kind of the problem with these tools lol, there is no obvious solution to this. Automatically fact checking an AI model would probably require a bigger and more sophisticated AI model.

E: That said this does look sick

We've tried to mitigate this recently. Does it still happen with Expert mode? If you have any examples, please send them my way and I'll talk a look at how we can address them.

Thanks for the example. Asking about the most recent version of something is something we'll work on, but it should give you good results if you ask it about a specific version. E.g. "What features were added in golang 1.20"

That's our secret sauce :)

We've built out a decently complex pipeline for this, but a lot of the magic has to do with the specific embedding model we've trained to know what text is relevant to feed in and what text isn't.

>This uses 2 things that GPT-4 doesn't know about yet: Swift 5.5+ and composable architecture 1.0+

Conversely, I asked it to tell me the current version of .Net Core. It returned version 6, the same answer as GPT-4, but the right had frame did return results indicating that version 7 is in fact the current release.

Sorry to hear this. What did you ask? And was it on Expert mode?

I had a similar experience. I asked if you can use CSS logical properties in IE11. It confidently told me YES with a whole bunch of follow-up.

The answer was no.

what's the right answer?

No catch. The feedback we get from this Show HN helps us improve and pays for itself.

Indeed, would love a clarification from OP. But given the tool's apparent quality it's very likely that it'll be SaaS'd after a trial MvP run.

There... is.

There will always be a free version but we are planning on introducing a pro version -- similar to ChatGPT Plus.

I asked OpenAI that exact question, this is what it said:

> One approach to finding the wall that would give you the best alternative path without having to remove every block and re-run A* is to use the concept of "edge weights."

> When you first run A* to traverse the maze, you can assign each edge a weight equal to the distance between the two adjacent nodes, which is equal to the Manhattan distance in your case. Once you have completed the traversal, you can go through each edge of the path that A* has found and temporarily increase its weight by some factor. Then, you can run A* again, but this time the pathfinder will prefer alternative paths that do not use those edges that have been "blocked" by the increased weight.

> By gradually increasing the weight of each edge one at a time, you can determine which wall would give you the best alternative path without having to re-run A* on the entire maze every time. You can also use a binary search-like approach to speed up the process.

> Here's some pseudocode for this approach:

    path = A_star(start_node, goal_node, edge_weights)
    
    for edge in path:
        original_weight = edge_weights[edge]
        edge_weights[edge] = original_weight * factor
        new_path = A_star(start_node, goal_node, edge_weights)
        if new_path is better than path:
            best_wall = edge
            path = new_path
        edge_weights[edge] = original_weight

> In this pseudocode, factor is the amount by which you increase the weight of each edge, and better than is some metric for determining whether a path is better than another (e.g., if it is shorter or has fewer turns).

Followed by this question: List ten most relevant links to the information you have summarized above.

> Here are ten relevant links related to A* search and maze traversal:

    "A* search algorithm" on Wikipedia: https://en.wikipedia.org/wiki/A*_search_algorithm
    "Manhattan distance" on Wikipedia: https://en.wikipedia.org/wiki/Manhattan_distance
    "A* Pathfinding for Beginners" tutorial on Red Blob Games: https://www.redblobgames.com/pathfinding/a-star/introduction.html
    "Introduction to A*" video on YouTube by Sebastian Lague: https://www.youtube.com/watch?v=-L-WgKMFuhE
    "A* Pathfinding Visualization" demo on GitHub by Qiao Zhang: https://qiao.github.io/PathFinding.js/visual/
    "A* Pathfinding Tutorial" on Amit's Game Programming Pages: http://theory.stanford.edu/~amitp/GameProgramming/
    "A* Pathfinding Algorithm" tutorial on GeeksforGeeks: https://www.geeksforgeeks.org/a-search-algorithm/
    "Introduction to Pathfinding" tutorial on Unity Learn: https://learn.unity.com/tutorial/introduction-to-pathfinding
    "Pathfinding in Games: A* Search" tutorial on Ray Wenderlich: https://www.raywenderlich.com/3016-pathfinding-in-games-a-search
    "Maze generation algorithm" on Wikipedia: https://en.wikipedia.org/wiki/Maze_generation_algorithm

> These links provide a range of resources, including tutorials, demos, and background information on A* search and maze generation.

Followed by: Please rewrite the lua code to golang.

    path := AStar(startNode, goalNode, edgeWeights)
    
    for _, edge := range path {
        originalWeight := edgeWeights[edge]
        edgeWeights[edge] = originalWeight * factor
        newPath := AStar(startNode, goalNode, edgeWeights)
        if newPath.isBetterThan(path) {
            bestWall := edge
            path = newPath
        }
        edgeWeights[edge] = originalWeight
    }

> In this Go code, AStar is a function that takes in the start and goal nodes, as well as the edge weights, and returns the optima...

    Use a more informed heuristic: The Manhattan distance heuristic used in the original code is a good general-purpose heuristic, but it may not be the most efficient for all maze configurations. Using a more informed heuristic, such as Euclidean distance or diagonal distance, can lead to faster convergence and fewer nodes being explored.

    Implement early termination: If you only need a suboptimal solution or are willing to tolerate some error in the solution, you can terminate the search early once a "good enough" solution has been found. For example, you can set a maximum number of nodes to explore or a maximum search depth.

    Prune search space: If you know some parts of the maze are not relevant to the solution, you can exclude those parts from the search space to reduce the number of nodes that need to be explored. For example, if you know the goal is located in a certain region of the maze, you can exclude nodes that are outside of that region from the search space.

    Use a better data structure: The performance of the A* algorithm is heavily dependent on the data structure used to store the open and closed sets. Using a more efficient data structure, such as a binary heap or Fibonacci heap, can speed up the algorithm.

    Parallelize the search: If you have access to multiple processing units, you can split the search space into multiple parts and run the A* algorithm in parallel. This can significantly reduce the search time, especially for large mazes.

The SO answer is pretty good and probably the most generalizable pathfinding solution.

My first thought was to also run A* from the end to the start. This would allow you to look at each wall in the maze and check if the A* cost from the start + A* cost from the end < best current path. In my opinion, this would result in simpler code than the SO solution.

Personally, I'd find that prompt difficult to understand without the title of the stackoverflow question. Did you include that?

Here you can apply the most common technique for such problems, which is to create a graph whose vertices are pairs made of a vertex of the original graph, plus the "state" of the traversal (or in other words, the essential information about the path used to reach the vertex).

In this case, the state is the number of walls passed, so just create a graph made of (v, k) pairs where for adjacent v and w in the grid, (v, k) connects to (w, k) if there is no wall, and it connects to (w, k + 1) if there is a wall.

Then run A*, finding the shortest path from (start, 0) to (end, 1), reconstruct the path and look at where it transitions from a (v, 0) to a (w, 1) and then return the wall between v and w.

You can use this for all sorts of other constraints, like finding a path that only changes direction up to N times, or a path where you don't get eaten by the monster moving deterministically (in this case the state is the monster position), or a path where you spend up to N time underwater consecutively, etc.

But GPT-4 seems very bad at solving problems, so even though this is an easy problem, it's not unexpected that it would not come up with this solution.

LLMs are notoriously bad at puzzle solving and you gave it a prompt that was very sparse on details. What did you expect?

> find out what wall would give me the best alternative path

This, specifically, and the question as a whole are hard to parse as a human. Before clicking through to the SO link (where there seems to be a lot more context), I wouldn't have guessed the problem you were trying to solve.

I'm curious why you changed the prompt at all? Was it to get the model to avoid your question's SO page?

> it's still on the level of CS undergrad.

I have 21 years of professional experience as a software engineer with a bachelor in CS before that and have never heard of "Manhattan distance metric", "A* implementation", "D*-lite" or "Theta*" until now. I'm sure if I'd read the explanation of those things I'd eventually figure it out (and I'm sure an LLM would make more sense if fed descriptions instead of gobbledygook.

Thank you :)

Thank you! We still have a lot of work to do, of course, and the feedback we get here will directly improve the service.

A better than google has existed for a while now. A new generation of web tools is what we've been asking for.

Google has non-aligned incentives with users and the gulf has been growing. Showing me the best answer is not the goal, showing me an ad is. I’m ready and willing to pay somebody who has a clear incentive to give me correct answers.

May I ask what the query was?